Comandos Básicos de la administración de Archivos

cd cd Downloads

Ingresar al subdirectorio (Downloads) desde el directorio raíz

cd ..

Éste cambiará al directorio raíz desde el directorio actual

cd ~

Éste comando irá al directorio de inicio del usuario que es \"/home/username\"

ls [opciones] [nombre]

Listar todos los archivos del directorio /usr/bin

Lista todos los archivos que empizan con la palabra ex dentro del directorio /usr/sbin

Lista todos los archivos con extensión .bin dentro del directorio /usr/sbin

.ls –R /Lista todos los archivos desde la raíz incluyendo los subdirectorios

. ls / Muestra los directorios contenidos en root

Lista los directorios empezando or root (/) y recursivo a tres niveles de directorio

. ls –a Muestra archivos y directorios ocultos:

.ls –i Muestra el nombre de archivo y el valor del inodo

cat Concatena archivos y puede ser utilizado para crear archivos; es utilizado principalmente para enviar contenido de uno o más archivos a la pantalla o a otro dispositivo de salida. La funcionabilidad del comando cat puede ser incrementada usando los símbolos de dirección > o > >. El símbolo > es llamado el redirector. Es utilizado para direccionar la salida hacia otro sitio que no se a la salida estándar, usualmente la pantalla. El > puede ser usado para escribir la salida de un comando a un archivo o a otro dispositivo, como es una impresora. El uso de > > también redirecciona la salida, pero agrega a un archivo existente en ves de sobrescribir. Para crear un archivo nuevo, escriba cat > nombre-del-archivo

Ctrl-D es el carácter end of file (EOF), fin de archivo, y cerrara el archivo. Para desplegar el contenido de uno o más archivos en la salida estándar, escriba: cat archivo1 archivo2

Esta sentencia desplegaría el contenido del archivo1 seguido por el contenido del archivo2. Nos podríamos ahorrar escribir un poco, con el uso de un comodín así: cat archivo?

Esta sentencia desplegaría el contenido de los cuales su nombre es archivo más un carácter único adicional. Si los únicos dos archivos que satisfacen este criterio son archivo1 y archivo2. Si no cabe dentro de la pantalla,puedes mostrar esos archivos en un archivo nuevo o mostrar el archivo utilizando el comando less. cat archivo1 y archivo2 | less Para combinar múltiples archivos en uno sólo, digite esta sentencia: cat archivo1 archivo2 archivo3 > archivo4 Crea un archivo nuevo de nombre archivo4, el cual incluye el contenido de los archivos archivo1, archivo2, y archivo3.

Si desea agregar el contenido del archivo1 al final del archivo2 escriba cat archivo1 > > archivo2

Sobrescribir un archivo ya existente cat > arcivo-existente Digitando el nuevo contenido del archivo El contenido original del archivo-existente desaparecerá y será reemplazado por el que digitamos.

Con la opción –b Numera todas las líneas exceptuando las que están en blanco

Si mostramos el contenido del fichero /etc/passwd tendremos algo parecido a esto: cat /etc/passwd

more y less Los paginadores (Pagers) son utilitarios usados para desplegar archivos y buscar información específica. Características de less incluyen: - La capacidad de utilizar las teclas del cursor - La capacidad de navegar con bookmarks, número de líneas, o porcentaje del archivo

- El less deja de ejecutarse al final del archivo, more continua

Limpiar la pantalla antes de mostrar el archivo.

Mostrar las dos primeras líneas del archivo especificado. Presionar Enter para mostrar el archivo línea a línea.

Muestra el archivo empezando por la segunda línea.

wc No despliega su contenido. Informa cuantas palabras, líneas, o caracteres contiene un archivo. wc [opciones] [nombre-archivo(s)]

Imprime número de líneas, palabras, caracteres, y el nombre del archivo:

Imprime número de líneas y el nombre del archivo:

Numero de líneas del acceso al usuario root

head y tail Visualiza el principio o el fin de uno o más archivos. La opción -n para designar cuantas líneas desea desplegar; el número a desplegar por defecto son 10. La opción -v o --verbose para imprimir siempre el nombre del archivo como cabezal. head es útil para identificar las primeras líneas de más de un archivo.

Desplegará lasdos primeras líneas de todos los archivos del directorio root, con extensión .txt. tail es útil para leer archivos log cuando nuevas entradas son agregadas.

Despliega las ultimas 7 líneas del archivo /var/log/cups/error_log. También podemos usar la opción + n con el comando tail así: tail + 15 /var/log/cups/error_log Empieza en la línea 15 y despliega cada línea hasta el final del archivo. Si usa la opción -f con tail, para supervisar interactivamente los nuevos mensajes son agregados al archivo log. Escriba así: tail -f /var/log/cups/error_log Mostrar cada nuevo mensaje al momento de ser escrito al log. Escriba CTRL-C para finalizar el despliegue a pantalla. touch Cambia la fecha y hora de acceso y modificación del archivo. touch [opciones] [fecha] nombre-de-archivo Si el archivo no existe será creado un archivo vacío. Si no especificamos la fecha y hora, la fecha actual del sistema será aplicado. Para cambiar la fecha y hora.

A la fecha actual.

Personalizar fecha a la indicada. Al no indicarse el valor de ss,es 0 En ambos casos de no existir el fichero se crearía. Si usamos -c y el archivo no existe touch no creará el archivo.

Cambiar el tiempo en que fue accesado un archivo usando la opción -a

Es imposible cambiar el ctime usando el comando touch. Cambiar el atime y el mtime manualmente En vez de tomar el actual time-stamp, podemos especificar manualmente usando las opciones -t y -d, con el siguiente formato para la opción -t: touch -t [[CC]YY]MMDDhhmm[.SS] Veamos el formato anterior en detalle: CC – Los dos primeros digitos del año. YY – Los dos ultimos digitos del año. Si el valor de YY está entre 70 y 99, el valor de CC se asume como 19. Si el valor de YY está entre 00 y 37, el valor de CC se asume como 20. No es posible asignar la fecha más allá del 18 de enero de 2038. MM – Para el mes DD – Para el día hh – Para la hora mm – Para el minuto SS – Para los segundos

cp Copia archivos y directorios. La acción de copiar puede reemplazar cualquier archivo existente con el mismo nombre, así que debe ser utilizado con cuidado. La opción -b (backup del archivo) o -i (interactivo). La opción -v para ver los archivos que se están copiando y a donde se están copiando los archivos. La opción -f para forzar la acción a realizar la copia sin preguntar Para copiar recursivamente un directorio y su contenido a otro, use la opción -r o -R. Copiará recursivamente la estructura del directorio. Para preservar los atributos de los archivos, incluyendo permisos, dueños, grupos, y etiqueta de tiempo, use la opción -p. La opción -P copiará la jerarquía del directorio así como los archivos. Copiar el fichero archivo.txt de mi directorio personal con el nombre archivo _copia.txt en el directorio /tmp (en el que todos los usuarios tienen permisos de creación de ficheros), podría ejecutar con éxito el siguiente comando independientemente de cuál fuera mi directorio actual.

Las opciones -i o –b, es útil si va a aplicar las opcione s -R o -P. Copia el contenido de archivo.txt a archivo-a.txt.

Para hacer una copia de seguridad del archivo copiado:

Una copia de seguridad de archivo.txt se creará con el símbolo "~" como archivo-a.txt ~. Copia carpetas y subcarpetas:

cp copia la carpeta y subcarpetas de Downloads a Directorios

Copiar un directorio Directorio y todo su contenido hacia un nuevo directorio llamado Directorio _respaldo:

Par visualizar cómo va haciendo cada paso, añadir la opción –v

mv: Mover/renombrar un archivo de un directorio a otro. El comando mv es distinto del comando cp ya que elimina completamente el archivo del origen y lo mueve a la carpeta especificada, mientras que el comando cp sólo copia el contenido de un archivo a otro.

-f No preguntará antes de sobreescribir (equivalente a --reply=yes). mv -f moverá los archivos sin preguntar incluso si está escribiendo sobre un archivo de destino existente.

-i Pregunta antes de sobreescribir algún archivo.

Para renombrar / mover un archivo: Renombra qacg.txt a fileqacg.txt

Para mover un directorio Mover todos los archivos, directorios y subdirectorios desde “directorio” a tmp si el directorio tmp ya existe. Si no existe el directorio tmp, renombra el directorio “directorio” a tmp.

Para mover archivos múltiples / más archivos a otro directorio, mover los archivos “archivo.txt”, “mover.bin” y “pagina.html” desde el directorio actual y al directorio tmp.

Mover “archivo.txt” desde el directorio actual /home/knoppix/ y el archivo mover.bin desde el directorio /tmp al directorio Downloads

rm elimina archivos de un directorio.

-f Elimina todos los archivos en un directorio sin preguntar al usuario.

-i Interactivo. Con esta opción, rm pide confirmación antes de eliminar cualquier archivo.

-r (ó) -R

Elimina directorios y subdirectorios reiterativamente en la lista de argumentos. El directorio será vaciado de archivos y eliminado. Normalmente se pregunta al usuario antes de eliminar cualquier archivo protegido contra escritura que contenga el directorio.

El directorio es vaciado de archivos y eliminado y nos pregunta si deseamos realizar esta tarea

Eliminar el archivo remover.txt.

Eliminar más archivos a la vez

mkdir Crear directorios si se usa sin opciones, el directorio padre debe estar ya presente para crear uno dentro que sería el directorio hijo, aquí le damos unos ejemplos: Crear el directorio qacg

mkdir –p -v [ruta de la carpeta incluyendo carpetas padre 1] [ruta de la carpeta incluyendo carpetas padre 2] La opción -v o --verbose nos muestra un mensaje por cada directorio creado. Crear una jerarquía de directorios de múltiple padre e hijos en una sola sentencia con la opción –p y -v.

Debe tener permisos de escritura al directorio padre para poder crear el directorio hijo. El por defecto en los directorios nuevos es de 0777, pero puede ser modificada por la variable umask del sistema, el perfil del usuario o usando la opción -m la cual establece los permisos sin tomar en cuenta los por defecto.

Crear un directorio con permisos

rmdir * solo borraria las carpetas vacias donde se ejecutara el comando, es decir que si dentro de una carpeta hay otra vacia no borraria ninguna de las dos

Si intentamos borrar un directorio que no este vacio nos dará un error tal como se visualiza a continuación

Borrar directorios vacios de manera recursiva

Expresiones Regulares grep:

selecciona y muestra las líneas de los archivos que coincidan con la cadena o patrón

dados.

Mostrar todas las líneas que contengan Java:

Mostrar la cuenta de lineas que contienen Linux:

Mostrar las líneas que empiezan por Li:

Para buscar los archivos en el directorios HEC que contengan la cadena \"include\": grep -c 'include' dir-1/* El comando anterior mostrará el nombre de archivo y la cuenta de líneas que contienen

la cadena \"include\"

Para buscar todas las lineas que contienen un solo carácter dentro de un archivo:

Buscar todas las líneas que solamente tengan un punto:

Seleccionar las lineas que tengan al menos una letra (mayúscula o minúscula)

Buscar una palabra que empieza por letra y puede contener números:[A-Za-z][A-Za-z0-9]*

Un dígito numérico, decimal:[0-9]

Una vocal: [AEIOUaeiou]

0, 1 o más ocurrencias de la ER “a” (repetición)

Localiza todos los ficheros de /etc que contiene la cadena eht0, incluye la opción -r, la búsqueda es recursiva, por lo que los ficheros de los subdirectorios de /etc se examinan de igual modo que los de éste. Para cada fichero de texto coincidente se imprimirá la linea que contenga la cadena.

Ubicar todos los ficheros de /etc que contengan la cadena eth0 o eht1. Puede introducir el siguiente comando, que emplea una expresión entre corchetes para especificar ambos dispositivos:

Lista de todos los procesos en ejecución llamados xterm, junto a sus PID

Otros ejemplos básicos

# grep '^La' fichero El comando anterior nos devuelve todas las líneas del fichero que comienzan por La. # grep '^ *La' fichero El comando anterior nos devuelve todas las líneas del fichero que comienzan por cualquier número de espacios seguido de La. # grep '^\..*' fichero El comando anterior nos devuelve todas las líneas del fichero que comienzan por punto y tienen cualquier número de caracteres. # ls -la | grep ' \..*' El comando anterior nos devuelve la lista de ficheros que comienzan por un espacio seguido de un punto y cualquier número de caracteres, es decir, la lista de ficheros ocultos. # ls -l | grep '^d' El comando anterior nos devuelve la lista de ficheros que comienzan por d, es decir, la lista de directorios. # grep -c -e "grep\|Unix" *.txt Otra opción interesante es la posibilidad de indicarle que no haga distinciones entre mayúsculas y minúsculas, usando la opción -i. Así, no hará distinción entre Unix o uNiX # grep -c -e "grep\|Unix" *.txt Indicar la línea en la que se produjo la coincidencia entre el patrón y la línea del fichero con la opción -n. # grep -n -e "grep\|Unix" *.txt Especificar una expresión regular que no queremos que se cumpla con la opción -v. # grep -v -c -e "grep\|Unix" *.txt Otros comando utiles

Estos son los comandos básicos a la hora de trabajar con enlaces:

Los siguientes comandos nos permiten obtener información del entorno en el que estamos trabajando:

El comando man tiene las siguientes opciones: Espacio avanza a la siguiente pantalla. b vuelve a la pantalla anterior. Flecha abajo Avanza una línea. Flecha arriba Retrocede una línea. Fin va al final del manual /expresión busca una expresión de la posición del cursor en adelante. ?expresión busca una expresión de la posición del cursor hacia atrás. N Busca la anterior aparición de la palabra buscada. n Busca la próxima aparición de la palabra buscada. q sale de las páginas del manual. Un mismo comando puede tener su página de manual en varias secciones. Por ejemplo, el comando halt (para apagar el sistema), tiene una en la sección 5 (dónde se explican las variables y otras opciones de su configuración) y otra en la sección 8 (como comando administrativo). Para acceder a una determinada sección del manual de un comando escribimos man numero_de_seccion comando por ejemplo “man 5 halt” Identificar un Sistema GNU/Linux El comando uname desplega al administrador del sistema, información sobre el equipo y el sistema operativo. -a, --all muestra toda la información

-m, --machine muestra el tipo de máquina (hardware) -n, --nodename muestra el nombre de `host’ del nodo de red de la máquina -r, --release muestra la distribución del sistema operativo -s, --sysname muestra el nombre del sistema operativo -p, --processor muestra el tipo de procesador -v muestra la versión del sistema operativo --help muestra esta ayuda y finaliza --version informa de la versión y finaliza

El comando hostname es en realidad un alias a uname -n y puede ser que no esté disponible en todas las versiones de GNU/Linux. Identificar los Usuarios Activos La familia de los comandos who retorna la identificación original de los usuarios durante el proceso de inicio de sección. La información desplegada del comando who es mantenida en /var/run/utmp. Un historial de cada login es también mantenido en /var/log/wtmp. Si el usuario subsecuentemente cambia su identidad con el comando su, el comando who le retorna el nombre original. El comando who también puede identificar el usuario actual, así como lo hace el comando id. Algunos sistema también tienen un comando w originalmente de BSD el cual es muy parecido al comando who.

En Linux, cada elemento de hardware es un dispositivo, y se encuentra representado en el directorio /dev mediante su correspondiente fichero de dispositivo. Este fichero existirá siempre y cuando el kernel esté compilado para soportar ese tipo de hardware, sino tendremos que compilarlo nosotros incluyendo las opciones de soporte para nuestro hardware. Los ficheros de dispositivo son conexiones con el hardware que permite que el kernel acceda a él. Los principales tipos de ficheros de dispositivo son los tipo bloque, los cuales transmiten los datos en bloques o paquetes, y los de tipo carácter, que trasmiten los datos bit a bit o byte a byte.

Si observamos las propiedades de alguno de los ficheros de dispositivos, podemos ver que no tiene tamaño (ya que no es una zona de almacenamiento), sino que tiene 2 números, el primero separado del segundo por una coma. Se trata del número principal (o major) que indica el tipo de dispositivo y el controlador asociado, y el número secundario (o minor) que identifica al dispositivo dentro de su tipo y es utilizado por el controlador.

Por ejemplo, para la partición 1 del primer disco duro, su número principal sería 8 y el secundario 1. Dispositivos: suelen estar en el directorio /dev. Representan a cada uno de los componentes de hardware que tiene el equipo. Toda aplicación que quiera usar un hardware debe hacerlo a través de este dispositivo. Enlaces: son archivos especiales que apuntan a otros archivos localizados en otras partes del sistema. Por ejemplo si necesitamos que un mismo archivo esté en /etc y en /var, podemos tenerlo en /etc y en /var crear un enlace al mismo; hay 2 tipos de enlaces: Duros: Tiene el mismo i-nodo que el archivo al que apunta. Si modificas uno de los 2, se reflejara en ambos, pero si borras uno, el otro permanecerá. No se pueden hacer enlaces duros a archivos en diferentes sistemas de archivos. Blandos o simbólicos: Tiene distinto i-nodo que el archivo al que apunta. Las modificaciones hechas en cualquiera de los 2 se ven reflejadas en ambos, pero si borras el original, el enlace queda apuntando a la nada. Se pueden crear enlaces simbólicos entre distintos sistemas de archivos. Socket: es un archivo especial en el que se intercambia información entre procesos. FIFO: o tubería, son archivos especiales para el intercambio de datos entre procesos; la diferencia con los sockets, es que en este caso el intercambio es unidireccional. Los flujos estándar son canales de comunicación entre un programa y el entorno en el que se ejecuta; se trata del stdinput (es el dispositivo por defecto para la entrada de datos; si no se redirige a otro, es el teclado, y su descriptor es el 0), stdoutput (es el dispositivo por defecto para la salida de datos; si no se redirige es la pantalla, y su descriptor es el 1) y el stderr (se usa para la salida de errores; por defecto es la pantalla, y su descriptor es el 2). Podríamos definir un nivel de ejecución como un estado del sistema, en el que se define como queremos que opere el sistema (que procesos arrancan, si hay red o no, si es multiusuario o no…). En los sistemas Linux existen 7 niveles de ejecución estándar:

Sudo permite una configuración especial que consiste en dar privilegios de un usuario (puede ser de root o de cualquier otro) a otro usuario o grupo, de tal forma que se puede configurar para que no les pida contraseña al ejecutar los comandos sobre los que tiene privilegios. Está configuración se encuentra en el archivo /etc/sudoers y para modificarla hay que ejecutar visudo

Como vemos, el archivo puede definir alias de usuarios, comandos y host. Esto nos permite asignar de forma más sencilla los permisos, sobre todo cuando se van a asignar los mismos a varias personas. Por ejemplo, así se definiría un grupo llamado alumnos que agruparía a 2: User_Alias ALUMNOS = ana, pablo Así se definiría un grupo de comandos relativos a la gestión de usuarios: Cmnd_Alias AD_USERS = /usr/bin/passwd, /usr/sbin/adduser Y así un alias de host: Host_Alias DC = 192.168.1.10, 192.168.1.101 Una vez definidos los alias (si así se quiere, no es obligatorio pero puede ser útil), hay que dar los permisos, la sintaxis es la siguiente: USUARIO/GRUPO HOST = COMANDO Para que no nos pida contraseña a la hora de ejecutar un comando existen las etiquetas PASWWD y NOPASSWD, por ejemplo si queremos que no pida para hacer un shutdown y un kill, pero sí para hacer un cambio de contraseña sería: NOPASSWD: /sbin/shutdown, /bin/kill, PASSWD: /usr/bin/passwd Por ejemplo si deseamos que el usuario profesor pueda cambiar las contraseñas del resto de usuarios sin necesidad de saber la contraseña de root tendríamos que tener una línea tal que: profesor ALL = NOPASSWD: /usr/bin/passwd O si queremos que al usuario tutor le deje crear usuarios sin contraseña, y apagar con contraseña en todos los equipos: tutor ALL = NOPASSWD:/usr/sbin/adduser, PASSWD:/sbin/shutdown Para configuraciones más avanzadas y otras opciones podemos consultar la página de ayuda tecleando man 5 sudoers

Comandos para comprimir Archivos Permite empaquetar y desempaquetar, y al mismo tiempo comprime si lo especificamos. Estas con sus principales opciones: c crea el paquete .tar y debe ir acompañado de la opción -f x desempaqueta un .tar y debe ir acompañado de la opción -f f indicar a tar que lo siguiente es el nombre del fichero .tar v mostrar los mensajes de salida que se dan durante el proceso. z para comprimir/descomprimir usando la utilidad gzip. j para comprimir/descomprimir usando la utilidad bzip2. t muestra el contenido de un .tar No hay que usar estas opciones de forma aislada, si no combinarlas entre ellas; veamos ejemplos del uso de tar: Empaquetar el directorio Directorio-respaldo en Respaldo-comp.tar viendo por pantalla los mensajes

Desempaquetar Respaldo-comp.tar ver mensajes por pantalla tar –xf Respaldo-comp.tar.tar Empaquetar y comprimir con gzip viendo por pantalla los mensajes tar –cvzf Respaldo-comp.tar.gz Directorio-respaldo/

Empaquetar y comprimir con bzip2 tar –cjf Respaldo-comp.tar.bzip2 Directorio-respaldo/

Descomprimir y desempaquetar con gzip tar –xzf Respaldo-comp.tar.gz Descomprimir y desempaquetar con bzip2 tar –xjf Respaldo-comp.tar.bzip2 COMANDO GZIP Nos permite comprimir y descomprimir archivos o directorios; aunque para descomprimir los archivos creados con gzip se puede también usar el comando gunzip. Crea archivos que tienen la extensión .gz. Veamos su uso: Comprimir un archivo: (hay que tener en cuenta que el original desaparece, y solo quedara el .gz generado): gzip archivo Descomprimir un archivo: puede hacerse de 2 modos gzip –d Respaldo-comp.gz gunzip Respaldo-comp.gz COMANDO BZIP2 Se utiliza para la compresión y descompresión de archivos y directorios. Crea archivos con extensión .bz2. Para descomprimir estos archivos, también se puede usar el comando bunzip. Ejemplos de uso: Comprimir un archivo: bzip2 archivo Descomprimir un archivo: bzip2 –d Respaldo-comp.bz2 bunzip Respaldo-comp.bz2 Lo siguiente es instalar el paquete, para ello tecleamos “apt-get install mc”. Ahora tecleamos mc

Ya tenemos abierto Midnight Commander. Intenta moverte por los distintos directorios tanto usando el ratón (sí, permite el uso del ratón) como por teclado, y prueba las opciones de búsqueda y filtrado que proporciona. Tienes la ayuda en la esquina inferior izquierda, si bien a continuación te muestro un pantallazo con cuales son las teclas más importantes para manejarte sin ratón:

Los sistemas de ficheros que Linux soporta pueden dividirse en 3 tipos: Sistemas basados en disco: discos duros, disquetes o CD/DVD Sistemas en red: Samba, NFS… Sistemas especiales Al referirnos a sistema de archivos nos referimos a sistemas basados en disco.

En sistemas Linux, una característica de los sistemas de archivos que se ha tenido en cuenta a la hora de diferenciarlos es que soporte journaling, dividiéndolos por ello en sistemas de archivos tradicionales y sistemas de archivos con journaling o transaccionales. El journaling simplemente consiste en que en los sistemas que lo soportan se va escribiendo un registro de todos los cambios o transacciones (entendemos por transacción un proceso que crea o cambia la información almacenada en el sistema) que se van a hacer y una vez registrados se escriben en “real” en el sistema de archivos, de modo que cuando una transacción falla, se pueden recuperar los datos que se manejaban en la misma. Sistema de Archivos Virtual o VFS: proporciona una capa de abstracción entre los sistemas de archivos y los procesos, es decir, es una capa intermedia que se coloca entre ambos, proporcionando unas interfaces definidas para tareas comunes como abrir archivos, leer o escribir archivos. Cuando un proceso hace una petición a un sistema de archivos, el VFS la adapta al correspondiente sistema de archivos, de modo que el proceso hará la petición de la misma forma independientemente del sistema de archivos usado. Sistemas de archivos tradicionales Dichos sistemas tienen una importante característica en común, que no soportan journaling. Ext2 (second extended filesystem): no es fácilmente fragmentable. Fue el sistema de archivos por defecto en varias distribuciones Linux (Debian por ejemplo), si bien, fue remplazado por su sucesor Ext3. Para explicar su funcionamiento, necesitamos conocer algunos conceptos como el de los inodos: son estructuras que contienen información (propietario, ruta, fecha…) de todos los archivos y carpetas de la partición. Cuando creamos el sistema de archivos, definimos el tamaño de los inodos, lo que condicionará el número máximo de archivos que puede haber en nuestro sistema. Los bloques son los espacios en los que se divide una partición. A la hora de crear el sistema de archivos debemos elegir con cuidado el tamaño del bloque (después no se puede cambiar), ya que este tamaño es el tamaño mínimo que ocupara un archivo en disco; así que si vamos a trabajar con archivos muy pequeños debemos asignar un tamaño de bloque pequeño. En ext2 los datos se almacenan en estos bloques, y un grupo de bloques secuenciales (32768) forman un grupo de bloques. Cada grupo de bloques contiene varios componentes, que son: Superbloque: contiene información del sistema de archivos tal como número de inodos y bloques libres, así como también el número de ocupados, o información de uso del sistema como tiempo desde el último chequeo. El superbloque está replicado en todo grupo de bloques para estar protegido ante posibles errores. Descriptor de grupo: en él se encuentran las estructuras que controlan la asignación de los bloques de ese grupo. También hay una réplica del mismo. Bitmap de bloques: recoge la información sobre que bloques de este grupo están ocupados o cuáles no. Bitmap de inodos: recoge que inodos están ocupados y cuáles no. Tabla de inodos: se almacena información de los datos como su propietario, permisos, fechas de modificación, y enlaces a los bloques de datos dónde se almacenan.

Bloques de datos: Es aquí donde se almacenan los datos. Es posible convertir un sistema de archivos ext2 a ext3, sin necesidad de formatear, permitiéndonos una migración de un sistema a otro sin pérdida de datos. Minix: sistema de archivos simple y compacto, diseñado para usarse en el sistema operativo MINIX (clon de UNIX). Estos sistemas de archivos tienen 6 componentes:

En el primer bloque del disco duro se encuentra el Bloque de arranque almacena el cargador de arranque, que carga y ejecuta un sistema operativo de arranque.

El segundo bloque se denomina Superbloque; guarda información para trabajar con el sistema de archivos.

El bitmap de inodos, que guarda información sobre que inodos están ocupados y cuáles no.

El bitmap de bloques, que guarda información sobre que bloques están ocupados y cuáles no.

El área de inodos. El área de datos en la que se almacena la información. VFAT: sistema de archivos que es una versión 32 bits del famosos sistema FAT

usado por los sistemas Microsoft en sus versiones anteriores. Sistemas de archivos transaccionales Soportan journaling, lo que los hace más seguros en caso de problemas que los sistemas tradicionales, ya que proporcionan la posibilidad de recuperar datos. Los más extendidos en los sistemas Linux son: Ext3: empieza a ser sustituido por ext4 y es la evolución de ext2. La principal diferencia entre ambos es que soporta journaling, pero también podemos destacar que, en general, proporciona un rendimiento superior que ext2. Aunque es más lento que otros sistemas de archivos, se considera más seguro y tiene menor consumo de CPU. En cuanto al journaling, ext3 permite 3 niveles: Diario (nivel de riesgo bajo): tanto los metadatos como el contenido se copian en el diario o journal. Pedido (nivel de riesgo medio): los metadatos se copian en el registro pero el contenido no, pero no marca el metadato como transcrito hasta que se asegura de que el contenido se escribe en disco. Es el nivel por defecto en la mayoría de las distribuciones de Linux. Reescritura (nivel de riesgo alto): los metadatos se copian en el registro pero el contenido no. El contenido del archivo puede escribirse en disco antes o después de que guarden los datos en el disco, lo que puede generar incoherencias entre las propiedades del archivo real y las que aparecen en el registro. Como ext3 se diseño para resultar compatible con ext2, no incorpora características recientes que si incorporan otros sistemas de archivos, lo que puede resultar una desventaja frente a sus competidores, como también lo son que no soporta compresión de forma oficial (pero sí de forma oficiosa). Ext4: es la evolución de ext3 (por tanto también implementa journaling) y está empezando a sustituirlo en muchas distribuciones. Aunque se diseño como una mejora

de ext3 que fuera compatible con él, proporciona importantes cambios, entre los que destacamos: Soporta volúmenes con tamaño de hasta un exabyte (que es 260 bytes). Soporta archivos con un tamaño de hasta 16 terabytes. Soporta un número ilimitado de subdirectorios (en ext3 el número máximo eran 32000). Usa extent, sustituyendo al esquema de bloques tradicional. Extent se basa en la reserva de bloques contiguos para un archivo, lo que reduce notablemente la fragmentación y mejora el rendimiento a la hora de trabajar con ficheros de gran tamaño. Mejora la fiabilidad del journal mediante chequeos de checksum. Permite chequeos del sistema de archivos más rápidos. Podemos destacar que un sistema ext3 puede ser montado como ext4 sin problemas; sin embargo, una partición ext4 solo puede ser montada como ext3 si esta no usa extent. ReiserFS: Fue el primero de los sistemas con journaling en ser incorporado en el kernel estándar de Linux. Este sistema de archivos trata a toda la partición como si fuera una única base de datos; los archivos, directorios y metadatos se organizan en una estructura de datos llamada árbol balanceado, de modo que no depende de los bloques. ReiserFS tiene una ventaja respecto a otros sistemas en el uso del espacio: aunque el tamaño del bloque por defecto es 4096 kbs, hace que el almacenamiento de los archivos pequeños sea más eficiente, y esto es así porque ReiserFS no utiliza un bloque entero para almacenar un único archivo, solo utiliza el espacio del bloque que necesita, pudiendo haber varios archivos distintos en un mismo bloque. En general, ReiserFS tiene la ventaja de proporcionar un sistema de almacenamiento eficiente, pero la desventaja de que el uso de los arboles balanceados requiere una gran capacidad de procesamiento. XFS: es un sistema de archivos rápido y eficiente de 64 bits. Como características principales podemos destacar las siguientes: proporciona una rápida recuperación tras un problema en el sistema, es bastante estable, tiene un buen rendimiento al trabajar con archivos grandes (se diseño como un sistema de archivos de alto rendimiento), y realiza las transacciones de forma rápida. JFS: este sistema de archivos fue creado por IBM para conseguir servidores de alto rendimiento, si bien actualmente está disponible con licencia GNU GPL, aunque no es de los más conocidos. Podemos destacar de él su estabilidad y eficiencia en el consumo de CPU y también en el uso del disco. NTFS: Aunque este sistema de archivos es realmente conocido por ser utilizado en las distribuciones de Microsoft, también es un sistema de archivos transaccional al que se puede acceder desde las distribuciones Linux. Después de haber explicado las características de los distintos sistemas de archivos, solamente nos queda indicar que es difícil decir cuál de estos sistemas es mejor que los demás, y que debes elegir uno u otro en función de las necesidades que vaya a

tener tu máquina; por ejemplo, si vas a trabajar con archivos muy pequeños (como un servidor de correo) ReiserFS sería una buena opción, o si vas a trabajar con archivos muy grandes XFS sería la tuya. Ext3 y ext4 serían buenas elecciones para usos de propósito general. Sistemas de archivos de acceso concurrente, los cuales permiten el acceso de varias máquinas al sistema de archivos a la vez; se suelen utilizar en la redes SAN y en los clústeres. En Linux podemos mencionar como sistemas de acceso concurrente a Global File System (GFS), Oracle Clúster File System (OCFS) o General Paralell File System (GPFS).

El punto de montaje de un dispositivo será el directorio en el cual se almacene el contenido del sistema de archivos montado. Forzar que lo monte con el comando mount : mount (-t tipo) (-o opciones) dispositivo punto_montaje

Tenemos que indicar que dispositivo vamos a montar (indicaremos el fichero que lo representa en /dev) y el punto de montaje para él. Además podemos indicarle que tipo de sistema de archivos es con la opción –t y algunas opciones con –o, como que lo monte solo en lectura o que lo monte en lectura y escritura. Tanto la opción –o cómo –t son opcionales. Por ejemplo para montar en el directorio /media/men_usb un pendrive que en /dev está representado por /dev/sda1 teclearíamos:

Para desmontar un dispositivo basta con ejecutar el comando umount acompañado del punto de montaje del dispositivo. Para el ejemplo anterior sería:

En el archivo /etc/fstab se guarda una lista de todos los dispositivos que se montan en el arranque, junto con sus puntos de montaje y opciones de montaje. Podemos ver todo lo que está montado en el sistema en un momento concreto visualizando el archivo /etc/mtab

Editor VIM:

En modo inserción, al que se accede desde modo normal pulsando i, nos moveremos en las distintas direcciones utilizando las flechas de dirección. El resto de teclas tendrán el significado habitual que tendrían en otro editor de texto. Para salir de modo inserción hay que pulsar la tecla ESC. FIND: Se trata del comando más potente a la hora de hacer búsquedas de archivos y directorios en modo texto en un sistema Linux. Veamos su sintaxis: find [ruta] [criterios] [acciones] Si no le ponemos ningún criterio, find nos mostrará todos los archivos del directorio actual y de todos sus subdirectorios. Si solo le indicamos la ruta, nos mostrará todo lo que contenga el directorio que le indiquemos. Si solo le pasamos los criterios de búsqueda, asume que tiene que buscar en el directorio actual y subdirectorios. Ruta: le indicamos dónde (en que directorio, y por extensión en sus subdirectorios) queremos que busque. Podemos indicarle tanto rutas absolutas (la ruta la comenzamos a dar desde raíz /) como rutas relativas (le damos la ruta tomando como punto de partida nuestra ubicación actual). Para pasarle la ruta, pueden utilizarse metacaraceteres (tales como *, ?). Buscar todos los archivos con extensión “txt”

Buscar los archivos qacg del 1 al 3

Al pasarle una ruta, find busca dentro de todos los subdirectorios del mismo, y si estos subdirectorios también tienen subdirectorios, también busca en ellos, y así sucesivamente. Para evitar esto, existen 2 parámetros que nos permiten indicar en qué profundidad de subdirectorios deseamos buscar, son estos (pueden combinarse): -maxdepth n siendo n un número; se le indica hasta que profundidad queremos que busque. Por ejemplo, si el directorio en el que buscamos tiene 5 subdirectorios y solo queremos que busque en los 3 primeros teclearíamos find /home –maxdepth 4 Ponemos 4 a pesar de que queremos ver el hasta el contenido del subdirectorio 3 por lo siguiente: si indicamos maxdepth 1 solo buscara dentro del directorio actual y no dentro de los subdirectorios, y si le indicamos maxdepth 2 buscara dentro del directorio actual y dentro del primer subdirectorio pero no en los subdirectorios que este pudiera tener, y así sucesivamente. -mindepth n siendo n un número; se le indica desde que subdirectorio hasta el final se quiere buscar. Por ejemplo, si tenemos un directorio con 5 subdirectorios, y solo queremos buscar en el último de ellos, sería mindepth 5 o si solo queremos buscar en los 2 últimos sería mindepth 4 Criterios: -name nombre pasamos el nombre del archivo que buscamos. Podemos usar expresiones regulares, pero si las utilizamos deben ir metidas entre comillas dobles (“”). Hay que tener cuidado con los metacaracteres y find por lo siguiente: cuando vamos a hacer un patrón de búsqueda como por ejemplo este –name “*p*” para encontrar un archivo que lleve p, no nos mostrara los que comiencen por p y no tengan ninguna otra en su nombre, ya que para find la p no podrá ser la primera letra de la palabra pues la presencia de un * o un ? al principio de la búsqueda implica que siempre hay un carácter al que sustituye (no es como en la Shell, donde podría o no haberlo), por tanto si la palabra empieza por p, no hay ninguna letra delante suya, y por eso no coincide con el patrón de búsqueda.

-type tipo buscamos un tipo de fichero, que puede ser: fichero normal (f), directorio (d), dispositivo de tipo bloque (b), dispositivo de tipo carácter (c) o enlace simbólico (l). Por ejemplo si buscamos un elemento que sabemos que es un directorio, sería:

-empty Busca todos los directorios y archivos vacíos. Si solo nos interesan los directorios, a los criterios de búsqueda añadiremos también -type d

-ctime [+/-]días busca los archivos y directorios cuya fecha de último cambio de estado (se refiere a cambios en la información de su i-nodo) sea inferior (ponemos -) o sea superior (ponemos +) al número de días indicado. Por ejemplo si queremos ver los modificados en los 2 últimos días y no antes, sería –ctime -2 De igual sintaxis que ctime son los parámetros -mtime [+/-]días (busca en función de que el contenido fue creado o modificado en esos días) y -atime [+/-]días (busca en función de la última vez que fue accedido el archivo, pero sin realizar cambios en su contenido).

-gid num siendo num el número identificador de un grupo del sistema. Por ejemplo si queremos buscar los archivos pertenecientes al grupo cuyo GID es 1000 sería:

-uid num siendo num el identificador de un usuario del sistema. Si queremos buscar los archivos pertenecientes al usuario cuyo UID es 0 sería:

-user usuario le pasamos como parámetro el nombre de un usuario y nos buscará los archivos que le pertenezcan.

-group grupo le pasamos como parámetro el nombre de un grupo y nos buscará los archivos que le pertenezcan. -size [+/-]tam[unidad] siendo tam el tamaño que queremos buscar. Podemos buscar que nos indique por un tamaño exacto (no ponemos n + ni -), o por un tamaño superior (ponemos + delante del tamaño) o inferior (ponemos -). Detrás del tamaño le ponemos la unidad en la que queremos que esté ese tamaño, sus abreviaturas son las siguientes: c es bytes; k es kilobytes; M es megabytes; G es gigabytes.

Acciones: en las acciones definimos si queremos hacer algo (ejecutar algún comando) sobre los archivos encontrados. Por defecto, los resultados se muestran, de modo que no hay que pasarle como acción visualizarlos. Para ejecutar las opciones se hace con –exec comando \; (el \; es porque cuando se pone la ejecución de un comando en find, la expresión debe terminar en ; , y para quitar el significado especial de ; lo precedemos de una \ ); si el comando que queremos ejecutar requiere llevar como parámetro el archivo encontrado lo indicaremos poniendo {} o sea –exec comando {} \; Lo mejor es verlo con un ejemplo, si queremos ejecutar un ls –l de todos los archivos que find encuentre sería:

find /home/user empty busca todos los archivos que se encuentran vacíos a partir del directorio /home/user. LOCATE: permite buscar archivos o directorios, es el equivalente a ejecutar un find –name loquesea sin embargo es mucho más rápido que él, ya que no busca el archivo en el disco, si no que lo busca en una base de datos que crea para estos fines. Por ello, antes de ejecutar una búsqueda con locate o después de instalar un nuevo software, es conveniente actualizar manualmente esta base de datos con el comando updatedb si bien, en muchas distribuciones el sistema se encarga de hacer una actualización de la misma todas las noches. Su sintaxis básica es: locate palabra -c no muestra lo que ha encontrado, si no le número de coincidencias encontradas. -i ignora mayúsculas y minúsculas a la hora de hacer la búsqueda (por defecto NO las ignora). -n num siendo num un número, solo nos mostrará el número de resultados indicado. En primer lugar, debemos saber que el script que arranca el servicio de red de nuestra máquina está en el directorio /etc/init.d y su nombre es networking, de modo que: Si queremos arrancar las conexiones de red ejecutaremos:

Si queremos reiniciar el servicio de conexiones de red, ejecutaremos:

Y para pararlas, será:

Una vez que tenemos el servicio arrancado, para ver la configuración IP de todas las interfaces de nuestra máquina ejecutamos el comando:

Vemos que para nuestra máquina, su resultado nos muestra 2 “secciones”, que corresponden a las conexiones que tiene la máquina, la primera llamada lo y la segunda llamada eth0. Por lo se refiere a la llamada interfaz de loopback, que se trata de una interfaz de red que siempre existe en los equipos Linux. Esta interfaz proporciona una conexión TCP/IP con la propia máquina. La eth0 representa a la primera tarjeta de red Ethernet que se localiza en nuestra máquina. Para todas las conexiones nos muestra una serie de información: En la primera línea, que comienza con el nombre del adaptador de red, se nos muestran los atributos de este adaptador: si está levantado (UP) o no (DOWN), si es una interfaz de loopback, su mtu… Para ver el estado de los adaptadores de red también podemos usar los comandos ifconfig o ip a que nos mostraran una información más o menos similar. Si queremos deshabilitar (DOWN) un interfaz de red concreta (por ejemplo eth0): ifconfig eth0 down o ifdown eth0 Y para levantarlo: ifconfig eth0 up o ifup eth0 Si sólo queremos ver el estado físico de una de nuestras tarjetas de red, lo haremos con el comando ip –s link show dispositivo Una vez que sabemos el estado de nuestra interfaz de red, puede interesarnos configurarla de otra forma, para ello disponemos de varios comandos: ifconfig dispositivo ip netmask mascara Por ejemplo: ifconfig eth0 192.168.1.2 netmask 255.255.255.0 ip address add IP/mascara brd broadcast dev dispositivo Por ejemplo: ip address add 192.168.1.2/24 brd 255.255.255.0 dev eth0 Este comando sería válido solo en el caso de que nuestra tarjeta no tuviera ninguna Ip en el momento en el que lo ejecutamos, si ya tenía una IP, la mantendrá y pondrá una segunda IP (alias) a la tarjeta de red. Si queremos borrar una de las IPs de la tarjeta sería así: ip address del IP dev dispositivo

Por ejemplo: ip address del 192.168.5.106 dev eth0 En Ubuntu, Knoppix, Debian y Fedora está configuración se encuentra en /etc/network/interfaces y en Suse, Mandriva se encuentra en el directorio /etc/sysconfig/network.

Por partes, en la primera sección se configura la interfaz de loopback. En la primera línea de su configuración se indica “auto lo” esto primero indica el modo en que la interfaz será levantada: de forma automática (auto), si la levanta algún subsistema ("allow-") o si depende de otro dispositivo físico (mapping); y después el nombre del dispositivo. Esta primera línea la llevan todos los dispositivos de red, adaptándola a sus necesidades. En la segunda línea se nos indica en nombre de la interfaz (iface lo), y su configuración IP (inet loopback). Veamos la siguiente sección en la que se configura una conexión con IP estática: en la primera línea, al igual que ocurría con la interfaz de loopback, le indicamos el modo de arranque y su nombre. En la segunda mostramos su nombre (iface eth0) y el tipo de configuración que tendrá (inet static), en este caso estática, de modo que le tendremos que dar los valores correspondientes a esta configuración: le pasamos la IP (campo address), la puerta de enlace (campo gateway) y la máscara de red (campo netmask): Por último, vemos la configuración de una conexión que tomará su IP de un servidor DHCP. En su configuración, al igual que en la de las demás, la primera línea debe contener su nombre y el modo de arranque. En la siguiente, la indicamos el nombre de la interfaz (iface eth1) y su modo de configuración (inet dhcp). Los servidores DNS responden a las peticiones de nuestra máquina. Esto se configura en el archivo /etc/resolv.conf que puede tener un aspecto similar a este:

Indicamos a nuestra máquina cuales son los servidores DNS a los que nuestro equipo realizará las peticiones, y esto se le indicamos con la directiva nameserver IPdelservidor Además podemos indicarle el nombre de dominio en que queremos que haga la búsqueda con la directiva domain nombredominio Este dominio de búsqueda

nos sirve para que cuando buscamos un nombre del host del cual no hemos puesto el dominio al que pertenece, lo intenta buscar dentro de este dominio. Un aspecto importante del equipo es su nombre, para modificarlo hay que hacerlo en el archivo /etc/hostname, el nombre que conste en este archivo será el de la máquina. Otros comandos que pueden interesarnos a la hora de configurar nuestra red son:

Este comando nos muestra las rutas por las que saldrán las peticiones de nuestro equipo a los distintos destinos. Por ejemplo:

Lo que vemos es que para ir a las redes 192.168.5.0/24, 192.168.1.0/24 y 169.254.0.0/16 se utiliza el dispositivo eth0, de modo que todo paquete que queramos enviar a esas redes saldrá por esa tarjeta de red. Por otro lado, en la última línea, lo que se define es la ruta por defecto que se seguirá para todos los demás destinos que no se listen anteriormente; por ejemplo para ir a la red 192.168.3.0/24, como no hay ninguna referencia a ella en la tabla de rutas, irá usando la interfaz por defecto eth0. ip route add red_destino dev dispositivo Este comando permite añadir rutas a la tabla de enrutamiento, lo que sirve para que cuando un paquete vaya a un determinado destino, si hemos añadido una ruta para él, siempre irá por ese camino. Por ejemplo, queremos que las peticiones de nuestra máquina que vayan a la red 192.168.1.0/24 vayan por la tarjeta eth1, sería así: ip route add 192.168.1.0/24 dev eth1 ip route add default via IP_gateway Con este comando añadimos la ruta por defecto, es decir, cuando queramos conectar con una red que no tiene ninguna entrada en la tabla de enrutamiento, irá por la puerta de enlace definida como por defecto. Por ejemplo, para añadir como ruta por defecto la puerta de enlace cuya IP es la 192.168.1.1 haríamos: ip route add default via 192.168.1.1 ip route delete red_destino dev dispositivo Nos permite quitar una entrada de la tabla de enrutamiento. Si quisiéramos quitar la ruta por defecto sería ip route delete default Para quitar por ejemplo el enrutamiento definido antes para la red 192.168.1.0/24 por la interfaz eth1, el comando sería: ip route delete 192.168.1.0/24 dev eth1 Ping: el comando ping nos permite comprobar la conectividad entre 2 hosts, su funcionamiento consiste en que un host envía un mensaje ICMP a otro, el cual debe

contestarlo con otro paquete ICMP que contendrá una secuencia de 32 bits y un identificador igual que el que le envío el otro host. Sintaxis: ip [opciones] ip_destino Algunas opciones destacables: I dispositivo nos permite especificar a través de que interfaz queremos que se haga la petición. Por ejemplo para hacer un ping a google.es por la eth3 sería: ip –I eth3 google.es c num num será el número de paquetes que mandaremos al host de destino del ping. En Linux, el número de paquetes enviado es indefinido, así que si no indicamos cuantos enviar, para parar el envío de estos mensajes tendremos que hacer un Ctrl+C. El comando ip addr list vendría a ser lo mismo que ejecutar ifconfig. Se puede ejecutar con el mismo resultado como ip address show o ip address list.

También podemos usar el comando ip link show para ver la información en capa 2 (data link layer) de las interfaces de red del sistema.

Para habilitar o deshabilitar una interfaz de red seguiremos utilizando ip link.

En el ejemplo anterior de como al levantar o tirar la interfaz desaparece la flag de UP en el ip addr list. En ifconfig se hace del siguiente modo.

Configurar una IP para la interfaz Con ip addr add podemos especificar la IP, máscara (también en formato CIDR como vemos a

continuación y la IP de broadcast.

Para eliminar la IP:

Telnet: el comando telnet nos permite comprobar si tenemos conectividad con un determinado puerto de otra máquina. Por ejemplo si queremosprobar la conectividad de nuestro equipo contra el puerto 25 de un servidor de correo llamado qacg.com sería:

Netstat permite ver la conectividad de nuestra red, sus opciones: -t Nos permite ver las conexiones TCP activas. -u Nos permite ver las conexiones UDP activas -r Muestra una tabla de enrutamiento. -p Muestra el programa que tiene la conexión abierta -l No muestra los puertos que están escuchando (esperando una conexión).

Estas opciones se pueden usar conjuntamente, lo que hace este comando de gran ayuda, por ejemplo para ver todos los puertos que están esperando conexiones TCP, teclearíamos: netstat –lt y para ver esa misma información y además el nombre del programa que la ha abierto sería

Traceroute: nos enseña la ruta que sigue nuestro paquete hasta llegar a su destino. Nos muestra la lista de routers por los que nuestro paquete pasa hasta llegar a su destino.

Donde se encuentre 'Dir' indica directorio, todos los demás son archivos.

Archivos de configuración en /etc

/etc/aliases Permite agregar alias (nicks) a nombres reales de usuarios de correo electrónico.

/etc/bashrc Funciones y alias disponibles para todos los usuarios, variables de entorno globales en /etc/profile.

/etc/cron.d Dir, archivos de cron personalizados para programas específicos.

/etc/cron.daily Dir, scripts de usuarios o de programas específicos que se ejcutan cada día, según lo definido en crontab.

/etc/cron.hourly Dir, scripts de usuarios o de programas específicos que se ejcutan cada hora, según lo definido en crontab.

/etc/cron.monthly Dir, scripts de usuarios o de programas específicos que se ejcutan cada mes, según lo definido en crontab.

/etc/cron.weekly Dir, scripts de usuarios o de programas específicos que se ejcutan cada semana, según lo definido en crontab.

/etc/crontab Controla archivos de cron para usuarios individuales o para el usuario root.

/etc/fedora-release Sustitue 'fedora' por el nombre de tu distro para ver la versión específica de tu distribución Linux.

/etc/exports Definición de directorios a compartir a través del sistema de archivos en red NFS.

/etc/filesystems Se usa para probar el orden de sistemas de archivos cuando se monta un dispositivo con la opción auto.

/etc/fstab Lista los sistemas de archivos montados automáticamente al arranque del sistema

/etc/group Almacena la información de los grupos del sistema, complemento de /etc/passwd

/etc/gshadow Guarda las contraseñas de los grupos asi como información de la caducidad de la misma, similar a /etc/shadow

/etc/host.conf Indica como en que orden se resuelven los nombres de equipo o de dominio.

/etc/hosts Define nombres de equipos igualándolos con sus direcciones IP.

/etc/hosts.allow Define un formato de acceso o lista de control de acceso de que equipos pueden ingresar al sistema.

/etc/hosts.deny Define un formato de acceso o lista de control de acceso de que equipos no pueden ingresar al sistema.

/etc/inittab Archivo de configuración para el comando init, determina el nivel de ejecución del sistema y define scripts de arranque.

/etc/issue Mensaje de bienvenida para todos las consolas antes del login.

/etc/login.defs Controla la configuración del login de usuarios (contraseña, caducidad, etc.) en sistemas que usan /etc/shadow

/etc/logrotate.conf Configura los parámetros del programa logrotate que a la vez administra archivos de bitácora (logfiles).

/etc/mtab Archivo dinámico que contiene una lista de los sistemas de archivos montados actualmente. Inicializado por init y actualizado por mount.

/etc/motd "Message Of The Day", mensaje que aparece a todos los usuarios después de loguearse a una terminal.

/etc/passwd La base de datos de usuarios del sistema, nombre, directorio de inicio, id del usuario, etc. Se complementa con las contraseñas almacenadas en /etc/shadow

/etc/printcap Archivo de configuración para las impresoras.

/etc/profile Variables de entorno globales a todos los usuarios. Funciones y alias van en /etc/bashrc

/etc/rc.d Dir, directorio que contiene los scripts de arranque del sistema y los directorios de los niveles de ejecucción.

/etc/rc.d/init.d Dir, scripts de arranque/detener de los diferentes programas servidores del sistema. en algunas distros esta en /etc/init.d

/etc/rc.d/rc.local Último script que se ejecuta al arranque del sistema, es el más adecuado para agregar nuestros propios script de arranque.

/etc/rc.d/rc0.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 0 (apagado del equipo).

/etc/rc.d/rc1.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al

nivel de ejecución 1 (monousuario, single user).

/etc/rc.d/rc2.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 2 (multiusuario).

/etc/rc.d/rc3.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 3 (red completa, multiusuario).

/etc/rc.d/rc4.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 4 (personalizado).

/etc/rc.d/rc5.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 5 (modo gráfico X11, red completa, multiusuario).

/etc/rc.d/rc6.d Dir, scripts de arranque(Start)/detener(Kill) cuando se ingresa al nivel de ejecución 6 (reinicio del equipo).

/etc/resolv.conf Configura la(s) dirección(es) del servidor de nombres de domino que resuelve para el equipo.

/etc/securetty Identifica las terminales en las que el usuario root puede loguearse.

/etc/services Lista de los servicios de red (tcp y udp) según la última lista de la iana.org

/etc/shells Lista de los shell (línea de comandos) confiables.

/etc/shadow Complemento de /etc/passwd, archivo donde se guarda la contraseña encriptada y demás datos de la misma de los usuarios del sistema.

/etc/sudoers Lista de usuarios con privilegios especiales de root y los comandos que pueden ejecutar.

/etc/sysconfig Dir, directorio donde se almacenan archivos de configuración relativos al equipo, teclado, mouse, red, etc.

/etc/ " /clock Permite definir la zona horaria y otros parámetros de la fecha y hora.

/etc/ " /i18n Parámetros LC (locale) y otros de internacionalización como sistema de medida, de moneda, código de teléfono, etc.

/etc/ " /init Variables de control de la forma en que inicia el sistema.

/etc/ " /iptables Iptables toma por default este archivo para cargar sus reglas al arranque del sistema.

/etc/ " /network variables de configuración global de parámetros de red.

/etc/ " /networking/devices

Dir, directorio que contiene la configuración de los dispositivos de red.

/etc/ " / " / " /ifcfg-eth0 Cada dispositivo (eth0, eth1, etc.) de red tiene su archivo de variables de configuración.

/etc/sysctl.conf Variables de configuración del kernel.

/etc/syslog.conf Control y configuración sobre la bitacorización de eventos del

sistema.

/etc/termcap Configuración de los atributos de la terminal o shell.

/etc/version Generalmente el número de versión de la distro.

Es importante señalar que no todos los archivos aqui mostrados existen en todas las distribuciones de Linux, puede haber y de hecho las hay importantes diferencias, pero en su gran mayoría esta guía aplica.

Practicas 1. Ir al directorio /usr/share/doc/info y allí copia los ficheros AUTHORS y copyright al

directorio /tmp.

2. En /tmp haz una copia del archivo AUTHORS que se llame AUTHORS2

3. Ahora añade el contenido del archivo copyright al archivo AUTHORS. Comprueba

que dicho contenido se ha añadido.

4. Reescribe lo que hay en AUTHORS con lo que hay en AUTHORS2. Muestra el contenido de AUTHORS haciendo un filtro que muestre solo las líneas dónde aparece la palabra “file” (sin comillas). En este mismo directorio crea un archivo vacio que se llame errores.txt.

7. Ahora ejecuta el comando ls –l noexiste redirigiendo la salida de errores al archivo Errores.txt. Crea un archivo vacio llamado todo.txt. Ejecutar el comando ls –l AUTHORS noexiste y redirige tanto la salida estándar como la de Errores.txt al archivo Todos.txt.

1. Ve al directorio /usr/share/doc/cron Haz un filtro del archivo copyright, para mostrar las líneas que empiecen por C (en mayúsculas).

5. Filtra las líneas de ese archivo que contiene la palabra GNU en mayúsculas y minúsculas.

4. Las líneas de copyright que contenga algún digito del 0 al 9.

Ejercicios con comandos básicos 1. Muévete al directorio /tmp y crea un directorio llamado Ejemplo1 que contenga un archivo llamado FileLinux.txt y un subdirectorio llamado NivelInterno.

2. Copia el directorio Ejemplo1 y su contenido a la home de tu usuario (su ruta será /home/nombreusuario).

Copia el directorio Ejemplo1 y su contenido a la home de tu usuario pero esta vez llámalo Ejemplo1-2Rename.

3. Muévete a la home de tu usuario. Accede a Ejemplo1-2Rename y cambia el nombre de FileLinux.txt a Archivo1.txt. Muestra el peso del directorio Ejemplo1-2Rename. Muestra el peso del archivo Archivo1.txt.

4. Borra el directorio Ejemplo1-2Rename. Vuelve a /tmp y cámbiale el nombre al directorio Ejemplo1 por PruebaLinux

5. Mueve el directorio PruebaLinux a la home de tu usuario. Muestra el peso de la home de tu usuario. Ejecuta el comando cd ~ y después ejecuta el comando pwd para saber en qué ruta te encuentras

6. Ingresa con root con el comando su y luego vuleve a la sesión que tenías y luego reinicia el equipo.

Ejercicios con comandos para el trabajo con archivos y enlaces Como ayuda para hacer los ejercicios, has de saber que el comando cd ~ te lleva directamente a la home del usuario. 1. En el home crea un archivo llamado file1 con el comando cat y agrega algún contenido durante su creación

2. Ahora crea un archivo sin contenido llamado file2.

3. Ejecuta un comando que te diga si file1 y file2 son iguales.

4. Ve al directorio /var/log y muestra las 10 últimas líneas del archivo llamado pm-powersave.log.

5. En ese mismo directorio muestra las 5 primeras líneas del archivo llamado syslog.

6. Muestra en tiempo real el final del archivo Xorg.0.log. Para salir de esta vista tienes que pulsar la combinación de teclas Ctrl+C

7. Accede al directorio prueba que está en tu home desde el ejercicio pasado. Cambia la fecha de última modificación a la actual del archivo que contiene.

8. Crea un enlace simbólico del archivo Archivo.bin en /tmp que se llame Acceso_Directo_Archivo.bin.

9. Comprueba a que i-nodo apunta Archivo.bin. Comprueba a que i-nodo apunta el enlace simbólico Acceso-Directo- Archivo.bin.

10. Crea en el directorio prueba de tu home un archivo llamado p1. Crea un enlace duro al mismo llamado p2, y comprueba si ambos comparten i-nodo o no.

11. Ejecuta el comando adecuado para ver quién es el propietario y el grupo del último enlace creado.

Ejercicios con comandos para el trabajo con consola 1. Muestra los 3 últimos comandos almacenados en el histórico.

2. Ahora limpia la pantalla

3. Muestra la fecha y hora del sistema y cámbiala a un día más tarde (se necesitan permisos de administrador).

5. Comprueba en que terminal está conectado el usuario root (a la hora de interactuar con él nos interesará el descriptor del terminal, no del escritorio que este sabemos que es tty7). La sesión en tty7 es la que tiene en el escritorio, y la pts/2 la del terminal en ese escritorio.

6. Envía un mensaje a root a su consola.

7. Muestra los últimos accesos al sistema

Ejercicios de compresión y empaquetado 1. Crear un directorio en tu home que se llame PracticaHome. Dentro de este directorio crea 2 ficheros llamado Datos.bin, Datos.txt. Crea además un directorio llamado SubDirHome que contenga un archivo llamado Docto.txt.

2. Copia el directorio /usr/share/doc/passwd el archivo NEWS.gz a la carpeta PracticaHome.

3. Descomprime el archivo NEWS.gz que se copio en el ejercicio anterior

4. Empaqueta con tar el directorio SubDirHome mostrando los mensajes de salida.

5. Comprime con gzip el paquete que generaste con SubDirHome. Vemos como al comprimirlo con gzip, le añade la extensión .gz al nombre del archivo.

6. Comprime con bzip2 NEWS.

7. Desempaqueta y descomprime SubDirHome con mensajes de salida.

8. Empaqueta y comprime con bzip2 SubDirHome.

Ficheros de configuración La tarea de asignar un gid a cada usuario, ponerle el tiempo de expiración de la contraseña, asignar los permisos que deberá tener por defecto cuando inicie sesión, etc uno a uno puede ser una tarea tediosa y puede alargarse mucho en el tiempo. Para simplificar la tarea existe el fichero /etc/login.defs. El contenido del fichero debería ser similar a este:

En él se pueden definir variables que usarán por defecto los comandos useradd y usermod a la hora de crear nuevos usuarios. A continuación se definen algunas de las variables que aparecen en el fichero: MAIL_DIR Directorio que se usará para albergar el correo. CREATE_HOME Si está puesto a "yes" creará un directorio a cada usuario que creemos por defecto. PASS_MIN_LEN Longitud mínima que debe tener la contraseña para que sea aceptada por el sistema. PASS_MAX_DAYS Número máximo de días que deben pasar entre cambios de contraseñas. Para el resto de opciones basta con leer la descripción asociada a ellas. Además del fichero /etc/login.defs existen también otros ficheros que podremos modificar para cambiar el comportamiento por defecto a la hora de trabajar con los usuarios que inicien sesión. Estos se encuentran en la ruta /etc/skel/ Si nos vamos a esa ruta y hacemos un ls para mostrar el contenido de la carpeta no veremos nada, esto es porque son ficheros ocultos y llevan un "." delante del nombre. Para mostrarlos debemos usar la opción -a: ls –a En el fichero .bash_logout se definen las acciones, programas, etc que se ejecutarán cuando se cierre la sesión. En el fichero .bashrc se definen los programas a ejecutar una vez iniciada la sesión del usuario. En el fichero .bash_profile se define sobre todo la configuración del entorno del usuario que se ejecutará al iniciar sesión.

Prácticas con la búsqueda 1. Vamos a preparar un directorio de búsquedas, para ello en tu home crea un

directorio llamado busquedas. Para esta practica ejecutar los siguientes comandos:

Visualizar la estructura vista con el comando tree: 2. Busca todo lo que contienen los directorios dir1, dir2 y dir3.

4. Muestra todo el contenido de las rutas que no empieza por F.

5. Muestra todo el contenido hasta el primer nivel de los subdirectorios.

6. Muestra todo el contenido a partir del segundo nivel de subdirectorios.

7. Muestra todo el contenido del primer y segundo nivel de subdirectorios.

8. Muestra todo cuyo nombre empiece por Dir

9. Muestra todo lo del primer nivel cuyo nombre acabe en un número del 1 al 3

10. Ahora dentro del directorio otro crea un enlace simbólico al archivo otro que contiene, llamado link. Además, en el propio directorio busquedas crea un link simbólico a f0 llamado link2.

11. Muestra todos los archivos de tipo directorio del directorio busquedas y todos sus subdirectorios.

12. Muestra todos los enlaces simbólicos a partir del primer nivel de subdirectorios.

13. Ve al directorio /dev y busca todos los archivos de tipo dispositivo de bloque.

14. Vuelve al directorio busquedas de tu home y busca todos los archivos vacios.

15. Ve a tu home y busca todos los archivos cuyo nombre contenga una l y que hayan sido modificados o creados en los 4 últimos días.

16. Ve al directorio /etc y busca los archivos pertenecientes al usuario root.

17. Busca como root en el directorio /etc los archivos con un peso superior a 50 kbs.

20. Con locate, busca todo cuyo nombre sea o contenga la palabra todo.

21. Con locate, muestra las 3 primeras coincidencias que detecte al buscar por config.

22. En el directorio /etc, busca emulando a root los archivos de todo tipo modificados o creados hace menos de 2 días cuyo propietario sea root y cuyo nombre contenga alguna e (pero no comience por e).

Comandos de gestión de usuarios El comando para añadir nuevos usuarios al sistema es useradd Algunos de los parámetros que se le pueden pasar son los siguientes: -u uid Con esta opción le asignamos el identificador de usuario manualmente al nuevo usuario del sistema. -g gid Con esta opción le asignamos el identificador del grupo primario al que pertenecerá el nuevo usuario del sistema. -G gid Con esta opción incluimos al usuario en otros grupos adicionales además del primario. -d directorio Con esta opción definimos el directorio de trabajo por defecto del nuevo usuario del sistema. -e fecha de expiración Con esta opción definimos la fecha de expiración de la cuenta del nuevo usuario en formato AAAA-MM-DD -p "contraseña" Con esta opción definimos en el propio comando useradd la nueva contraseña del usuario. -s shell Con esta opción definimos el intérprete de comandos que podrá utilizar el usuario. Como norma general se utiliza bash como intérprete de comandos por defecto. -c comentario Con esta opción le asignamos un comentario a la cuenta del usuario que vamos a crear. Como ejemplo, si quisiéramos crear un nuevo usuario que se llame "Pepito" con UID 5000, cuyo directorio home fuera /home/pepito y cuya cuenta expirara el 1 de enero de 2012 utilizaríamos el siguiente comando: useradd -u 999 -g 850 -d /home/pepito -e 2012-01-01 Pepito Para más opciones sobre useradd así como cualquier comando del sistema basta con consultar su página man man useradd Una vez creado el usuario podemos asignarle la contraseña con el comando passwd. La sintaxis del comando es la siguiente: passwd parámetros usuario

Algunos de los parámetros usados por el comando son: -l Con esta opción bloqueamos la cuenta del usuario. Convierte la contraseña en una cadena inválida añadiéndole el carácter "!". -u Con esta opción hacemos lo contrario que con la opción -l. Desbloquea la cuenta del usuario y le quita el prefijo ! -n días Con esta opción indicamos el tiempo mínimo de vida en días para la contraseña del usuario. -x días Con esta opción indicamos el tiempo máximo de vida en días para la contraseña del usuario. -w días Con esta opción indicamos el número de días a partir del cual el usuario recibe un warning diciendo que debe cambiar la contraseña antes de que expire. Cuando se crea un nuevo usuario del sistema, su información se almacena en el fichero /etc/passwd al cual sólo puede acceder el usuario root y no se deberían modificar dichos permisos a no ser que sea imprescindible. Además de los usuarios que creemos nosotros, en ese fichero aparecen también las cuentas de los usuarios del sistema como Apache2 o bind9.

Si mostramos el contenido del fichero /etc/passwd tendremos algo parecido a esto: cat /etc/passwd

El formato del fichero especifica siete campos distintos, cada uno de ellos separado por ":" Los campos corresponden con lo siguiente: 1. Nombre de la cuenta del usuario. 2. Contraseña del usuario codificada. No nos serviría de nada intentar modificar la contraseña del usuario aquí ya que no único que conseguiríamos es que la cuenta quedara bloqueada. La x hace referencia también a que se está usando el archivo /etc/shadow. 3. El número del identificador de usuario (UID) 4. El número del identificador del grupo al que pertenece el usuario (GID) 5. El comentario que le hayamos asignado al usuario. Si no le hemos asignado ningún comentario, este campo quedará vacío. 6. El directorio de trabajo del usuario al cual se conectará por defecto al iniciar sesión en el sistema. 7. La shell o intérprete de comandos que utilizará el usuario al iniciar sesión en el sistema. No todo el contenido de las cuentas de los usuarios se almacena en el fichero /etc/passwd. Dado que cualquier usuario puede leer el fichero (aunque no modificarlo), es posible que con el tiempo y una buena herramienta de desencriptado, cualquier usuario llegara a conocer las contraseñas de los demás si estas aparecieran en el fichero. Para solucionar este problema existe el fichero /etc/shadow. La x que aparece en el campo contraseña de los usuarios en el fichero /etc/passwd significa que se está utilizando el archivo /etc/shadow al cual sólo puede acceder root y de esta forma se evita que cualquier usuario del sistema acceda a las contraseñas cifradas. Si no se hiciera uso de /etc/shadow, en el campo de contraseña aparecería directamente la contraseña cifrada.

El contenido del archivo /etc/shadow debería ser similar a este:

Podemos apreciar cómo aparece la contraseña cifrada de root y cómo no aparece la de los usuarios del sistema al no tener ninguna asignada y por lo tanto no poder iniciar sesión en el sistema. Los campos que aparecen en el fichero /etc/shadow se corresponden con: 1. Nombre del usuario. 2. Contraseña cifrada. En el caso de que aparezca "*" la cuenta no puede iniciar sesión. 3. Número de días transcurridos desde el 1 de enero de 1970 hasta la fecha en la que la contraseña fue cambiada por última vez. 4. Número de días hasta que la contraseña se pueda cambiar. 5. Días en los que expira la contraseña y por lo tanto hay que cambiarla. 6. Días antes de la expiración de la contraseña a partir del cual se le enviarán notificaciones al usuario para que la cambie. 7. Número de días después de que expire la contraseña tras los cuales se inhabilitará. 8. Día en el que caduca la cuenta. Se cuenta a partir del 1 de enero de 1970. Para modificar la información de un usuario creado previamente se utiliza el comando usermod. La sintaxis del comando es la siguiente: usermod parámetros usuario A parte de los comandos que se le pasan a useradd se le pueden pasar entre otros: -L Bloquea la cuenta de un usuario impidiendo que acceda al sistema. -U Desbloquea una cuenta de usuario bloqueada previamente con la opción -L

-l nuevo nombre de usuario Cambia el nombre de usuario con el que iniciará sesión en el sistema. -a nombre de grupo Añade al usuario a otro grupo. Hay que usarlo siempre con la opción -G. -G grupos Especifica el grupo o los grupos a los que se añadirá al usuario. Para poder eliminar un usuario, se utiliza el mandato userdel. La sintaxis del comando es la siguiente: userdel parámetros usuario Userdel, si no se le pasa ningún parámetro eliminará la cuenta del usuario de los ficheros /etc/passwd y de /etc/shadow pero no eliminará ni su directorio de trabajo ni los ficheros que hubiera ahí. Si le pasamos la opción -r se eliminará la cuenta de /etc/passwd y /etc/shadow y también su directorio de trabajo y los archivos que haya en el. Si el usuario está logueado en el sistema no dejará eliminarlo. Por último, la opción -f hace lo mismo que -r pero da igual si el usuario se encuentra logueado o no. El comando chage para modificar los tiempos de expiración de las contraseñas entre otras cosas. La sintaxis del comando es: chage parámetros usuario

Los parámetros más utilizados son los siguientes: -m días Número mínimo de días entre cambios de contraseñas. -M días Número máximo de días entre cambios de contraseñas. -E fecha Día en el que expira la cuenta en formato AAAA-MM-DD -W días Número de días antes de que el usuario tenga que cambiar la contraseña en el que se le empezarán a enviar "warnings" Por ejemplo, si quisiéramos que la cuenta de pepe expirara el día 31/dic/2011, lo haríamos de la siguiente forma: chage -E 2011-12-31 pepe

Además de los comandos aquí expuestos, hay otros que resultan útiles a la hora de trabajar con usuarios y grupos como son los siguientes: id nombre de usuario Muestra información sobre la identidad del usuario. Ejemplo: id knoppix

finger nombre de usuario Muestra información detallada de los usuarios. finger knoppix

groups nombre de usuario Muestra los grupos en los que está incluido un determinado usuario. groups knoppix

Gestión de usuarios 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root. Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root: su – 2. Crea seis cuentas de usuario llamadas ana, mercedes, luis, ruben, yolanda y miguel con contraseña "12345" sin las comillas. Comprueba que estén creadas correctamente.

Creamos las cuentas de usuario:

A continuación les asignamos las contraseñas:

Comprobamos que se han creado correctamente: cat /etc/passwd

cat /etc/shadow

3. Haz que las contraseñas de las cuentas recién creadas deban ser cambiadas cada 60 días y que la cuenta de yolanda expire el día 31/12/2011. Comprueba que se ha asignado correctamente.

Hacemos que las contraseñas de los usuarios recién creados caduquen cada 60 días:

Ahora hacemos que la cuenta de user4 expire el día 31/12/2011:

Comprobamos que las 4. Se decide establecer una política de seguridad por la cual, todas las contraseñas deben ser cambiadas cada dos meses. Define en el sistema la política por defecto para que las cuentas creadas en el futuro tengan que cambiar la contraseña también cada 60 días. Crea una cuenta llamada prueba y comprueba si se le aplica la política que hemos modificado. Borra la cuenta prueba y también sus carpetas. A continuación definimos la política por defecto para que las nuevas cuentas que se creen tengan que cambiar la contraseña también cada 60 días: joe /etc/login.defs Modificamos el parámetro PASS_MAX_DAYS del fichero:

A partir de ahora todas las cuentas que se creen deberán cambiar la contraseña cada 60 días. Creamos la cuenta llamada prueba: useradd prueba Comprobamos que se aplica la política: cat /etc/shadow

Efectivamente le pide cambiar la contraseña cada 60 días. Borramos la cuenta prueba así como sus carpetas: userdel -r prueba 5. La contraseña especificada "12345" es muy sencilla y por lo tanto poco segura, haz que los usuarios tengan que cambiar su contraseña inmediatamente en el siguiente inicio de sesión.

Hacemos que los usuarios cambien su contraseña la próxima vez que inicien sesión: chage -d 2010-01-01 ana chage -d 2010-01-01 mercedes chage -d 2010-01-01 luis chage -d 2010-01-01 ruben chage -d 2010-01-01 yolanda chage -d 2010-01-01 miguel Con especificar cualquier día anterior al actual es suficiente. 6. Añade una política para hacer que las contraseñas tengan un mínimo de 7 caracteres para añadirle complejidad. Prueba a conectarte con miguel a la máquina. Se te debería pedir que cambies la contraseña del usuario y esta debería tener un mínimo de 7 caracteres.

Vamos a añadir la política por defecto para que las contraseñas tengan un mínimo de 7 caracteres. Editamos el fichero /etc/login.defs y fijamos el parámetro PASS_MIN_LEN a 7: joe /etc/login.defs

Probamos a loguear con miguel:

Al introducir la contraseña nos aparece un cartel diciendo que debemos cambiarla:

Ahora si intentamos introducir una contraseña de menos de 7 caracteres no nos dejará. También podemos probarlo conectándonos por ssh vía consola: ssh miguel@127.0.0.1

7. Crea un séptimo usuario llamado gonzalo mediante la herramienta gráfica system-config-users, asígnale la contraseña "g.2011," y el uid 2011

Vamos a crear el usuario gonzalo. Con la cuenta de root, en la terminal de la máquina escribimos lo siguiente: system-config-users Con lo que se nos abrirá el interfaz gráfico de creación de usuarios. Nos vamos a añadir usuario:

En nombre de usuario escribimos gonzalo, de contraseña le asignamos "g.2011,", marcamos la casilla "especificar el ID del usuario manualmente" y le asignamos el 2011, le damos a aceptar. Comprobamos que se ha creado correctamente:

Gestión de grupos El comando para añadir nuevos grupos es groupadd que se construiría así: groupadd parámetros grupo Podemos cambiar la información de un grupo mediante groupmod: -g GID Le cambiamos el GID al grupo. -n nuevo nombre del grupo Se le cambia el nombre al grupo. -A usuario Se añade al usuario al grupo especificado. Podemos eliminar un grupo mediante el comando groupdel La información sobre los grupos que hay creados así como los usuarios que pertenecen a cada uno se puede ver en el fichero /etc/group Si mostramos el contenido de dicho fichero deberíamos ver algo parecido a lo siguiente:

Los campos de dicho fichero se corresponden con: 1. Usuario. 2. Contraseña del grupo. Aparece una x al no tener contraseña, si tuviera alguna, se mostraría encriptada. 1. El GID o identificador de grupo. 4. Grupos a los que pertenece el usuario. 1. Conéctate a tu máquina Centos y utiliza la cuenta de root.

Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root:

su -

2. Añade los grupos cpi, gestion y comercial con los gid 2001, 2002 y 2003 respectivamente. Comprueba que se han creado correctamente.

Añadimos los grupos con los gid especificados:

Comprobamos que se han creado correctamente: cat /etc/group

3. Cámbiale el nombre al grupo gestion por el de administracion. Comprueba que ha cambiado su nombre.

Le cambiamos el nombre al grupo gestion por el de administracion:

Comprobamos el cambio de nombre: cat /etc/group

4. Añade a ana y miguel al grupo auxiliar cpi, a luis y ruben al grupo auxiliar comercial y a yolanda y mercedes al grupo auxiliar administración. Comprueba que han sido asignados correctamente. Añadimos a los usuarios a sus respectivos grupos: usermod -aG cpi ana usermod -aG cpi miguel usermod -aG comercial luis usermod -aG comercial ruben usermod -aG administracion yolanda usermod -aG administracion mercedes Ahora comprobamos que han sido asignados correctamente: cat /etc/group

5. Ahora añade a gonzalo a todos los grupos auxiliares anteriores mediante la herramienta gráfica. Con la cuenta de root, en la terminal de la máquina escribimos lo siguiente: system-config-users Seleccionamos el usuario gonzalo y le damos a propiedades:

Se nos abrirá un cuadro con las opciones que podemos modificar del usuario gonzalo. Nos vamos a la pestaña grupos:

Ahora deberemos marcar los grupos a los que queremos añadir a gonzalo y darle a aceptar.Nos vamos a la pestaña grupos de la pantalla de inicio y comprobamos que ha sido agregado correctamente:

El sistema de cuotas La administración del espacio en disco es vital para cualquier sistema. Los recursos de los que dispone una máquina son limitados y por lo tanto si varios usuarios van a trabajar en un determinado equipo se debe implementar algún mecanismo que establezca un límite en el número de recursos que se van a utilizar. Con el fin de gestionar el espacio en disco existe el concepto de cuota. Las cuotas se establecen en una determinada partición del sistema y se pueden aplicar a usuarios usrquota, a grupos grpquota o a ambos. El comando quotacheck se utiliza para analizar el espacio en disco, crear o reparar archivos de cuota. Algunos de los parámetros que se le pueden pasar son:

-m Se fuerza al sistema a comprobar el sistema de archivos en modo lectura-escritura. -a Comprueba todos los sistemas de archivos. -v Va informando del progreso de la operación mientras esta se ejecuta. -u Sólo se comprueban las cuotas de usuario. -g Sólo se comprueban las cuotas de grupo. Con los comandos quotaon y quotaoff podemos habilitar o deshabilitar las cuotas en el sistema de archivos. quotaon: -v Enseña un mensaje por cada sistema de archivos en el que las cuotas están activadas. -a Activa las cuotas para todos los sistemas de archivos. quotaoff: -a Deshabilita las cuotas en todos los sistemas de archivos. -v Enseña un mensaje por cada sistema de archivos afectado. Con el comando repquota se puede obtener información del estado de las cuotas en un determinado sistema de archivos. -a Saca un reporte completo del estado de las cuotas. -u Saca por pantalla las cuotas de los usuarios. -n No resuelve los UID/GID en nombres, esto puede acelerar considerablemente el proceso de reporte. Con el comando edquota podemos establecer la cuota de un determinado usuario. Al ejecutarlo, se modificará el fichero mediante el editor vi y habrá varias columnas que modificar. Las columnas "blocks" e "inodes" son informativas e indican la cantidad de bloques e inodos utilizados actualmente por el usuario. Lo habitual es establecer los límites (soft, hard) en el número de inodos o en el de bloques pero no en los dos a la vez aunque esto sería también posible. Los bloques ocupan un 1KB por lo tanto para establecer una cuota de 5MB a un usuario deberíamos asignarle 5000 bloques. Los inodos representan el número de archivos que un usuario puede crear en el sistema. Cuando el usuario rebase el límite soft se le notificará la usuario y entrará en el "periodo de gracia". Cuando se acabe el periodo de gracia (por defecto 7 días) o el usuario llegue al límite hard, no podrá crear más archivos hasta que elimine algunos. Algunos de los parámetros de edquota son: -p usuario1 usuario2 Copia el patrón de cuotas del usuario1 al usuario2. -u Edita las cuotas de los usuarios. -g Edita las cuotas de los grupos. Vamos a implementar el sistema de cuotas para usuario en nuestro sistema Centos. Para ello habrá que añadir la opción usrquota a la partición / y volver a montarla para que surtan efecto los cambios. Usando el usuario root editamos el fichero /etc/fstab. El fichero /etc/fstab indica las particiones disponibles así como las opciones aplicadas a cada partición. joe /etc/fstab y añadimos la opción usrquota en las opciones de la partición /

Volvemos a montar la partición / con la opción que le acabamos de añadir: mount -o remount / Con la opción -o le decimos a mount que vuelva a montar (remount) la partición. Le decimos al sistema que cree el fichero necesario para gestionar las quotas mediante el comando: quotacheck -mavu Lo cual debería habernos generado en la raíz / el fichero aquota.user: ls -a /

Finalmente le decimos al sistema que habilite las quotas con el comando: quotaon / Ya tenemos habilitado el sistema de cuotas. Gestión de cuotas de usuarios 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root.

Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root: su -

2. Establece una cuota de disco para el usuario miguel de 50MB. Comprueba que se le ha asignado correctamente.

Establecemos la cuota del usuario miguel: edquota miguel

El fichero se editará con vi. Le damos a la "i" para insertar. Vamos al valor de hard de los bloques y para asignarle 50MB le ponemos el valor 50000. Una vez que hayamos acabado le damos al "Esc" , escribimos ":x!" sin las comillas y le damos al "enter" para salir guardando

Comprobamos que la cuota ha sido asignada correctamente: repquota –a

3. Loguéate como miguel y ejecuta el comando dd if=/dev/zero of=archivo bs=1k count=4000. ¿te ha dejado crearlo? Comprueba la cuota que le queda al usuario. Nos logueamos como miguel: ssh miguel@127.0.0.1 Ejecutamos el comando dd if=/dev/zero of=archivo bs=1k count=4000:

Comprobamos la cuota del usuario: quota

Tiene ocupados 4 de los 50MB. 4. Ahora ejecuta el comando dd if=/dev/zero of=archivo2 bs=1k count=100000 ¿Te ha dejado crearlo?

Ejecutamos el comando dd if=/dev/zero of=archivo bs=1k count=100000:

En lugar de los 100MB que tenía que tener el archivo, lo ha dejado en 47 MB debido a que el usuario ha alcanzado el límite de su cuota. quota

5. Vuelve a usar la cuenta de root y crea un archivo con el comando dd if=/dev/zero of=archivo3 bs=1k count=50000 en /home/miguel. ¿Te deja? ¿Por qué? Usamos la cuenta de root: su – Vamos a la carpeta de miguel: cd /home/miguel Creamos el archivo3 con el comando dd if=/dev/zero of=archivo3 bs=1k count=50000

El archivo se ha creado correctamente porque la cuota se aplica por usuario y no por directorio. Miguel tiene la cuota llena pero el fichero creado por root no altera esa cuota en ningún momento.

6. Utiliza como plantilla la cuota de miguel para asignarle la misma al resto de usuarios. Comprueba que se ha establecido correctamente. Le asignamos la cuota al resto de usuarios con la cuota establecida para miguel como plantilla: edquota -p miguel ana edquota -p miguel luis edquota -p miguel ruben edquota -p miguel mercedes edquota -p miguel yolanda edquota -p miguel Gonzalo Comprobamos que se ha establecido correctamente: repquota –a

De esta forma se agiliza el proceso de asignación de cuotas. El comando dd transfiere datos de un dispositivo a otro. En este caso se ha utilizado para, desde el fichero origen /dev/zero, producir un archivo con bloques de tamaño 1k, hasta completar tantos bloques como aparezcan en el parámetro "count" Así podemos hacer pruebas con las cuotas de los usuarios. Gestión de permisos de usuario Existen tres tipos de permisos: r=lectura Cualquier usuario que tenga permiso de lectura sobre un directorio podrá mostrar su contenido. Si el permiso de lectura lo tiene sobre un archivo, podrá ver su contenido. w=escritura El usuario que tenga permisos de escritura sobre un determinado directorio podrá crear y borrar nuevos archivos en el. Si está asignado a un archivo, podrá modificar su contenido. x=ejecución Cuando se tiene este permiso sobre un directorio, el usuario puede acceder a el, mientras que si se trata de un archivo, este podrá ser ejecutado. Podemos mostrar los permisos de los archivos de un directorio mediante el comando ls -l, a continuación se muestran, por ejemplo, los permisos de la carpeta /tmp:

Hay nueve campos en total separados por espacios. Vamos a coger, por ejemplo, el último directorio que aparece "virtual-root.eflZcm"

El primer campo lo compone drwx------ El primer carácter que aparece "d" indica el tipo de archivo que en este caso es un directorio "d", los siguientes nueve caracteres indican los permisos efectivos para ese archivo. De esos nueve caracteres, los tres primeros rwx indican los permisos para el propietario del archivo. En este caso el propietario tendría permisos de lectura, escritura y ejecución. Los siguientes tres caracteres indican los permisos efectivos para el grupo propietario del archivo. En este caso, el grupo propietario no tendría ningún permiso sobre el archivo en cuestión. Los últimos tres caracteres indican los permisos efectivos para "otros", es decir, cualquiera que no sea el propietario o pertenezca al grupo de propietarios. En este caso no tendrían ningún permiso efectivo sobre el archivo. Así pues, cada grupo de tres caracteres representa los permisos efectivos del propietario, el grupo y otros. El siguiente campo de los nueve que nos interesa es el tercero. Ese campo nos dice quién es el propietario del archivo en cuestión, en este caso root. El cuarto campo corresponde al grupo propietario del archivo, en este caso root. El quinto campo nos dice el tamaño del archivo en bytes. El resto de campos se corresponden con la fecha y la hora en la que el archivo fue modificado por última vez. Todos los usuarios cuando crean cualquier archivo en el sistema se crea con unos permisos determinados. Estos permisos vienen dados por la llamada "máscara" que se aplica a los usuarios. Esta máscara se puede definir en el fichero /etc/profile para que la usen todos los usuarios del sistema o bien podemos asignarla sólo al usuario que deseemos añadiendo la opción umask en el fichero .bashrc_profile que se encuentra en el directorio home de cada usuario. Su función es quitar a los ficheros y directorios, los permisos que le hayamos especificado. Los directorios tienen permisos 777 y los ficheros 666, de tal forma que si para un usuario tenemos una máscara 022, los permisos efectivos que tendrían los directorios que creara serían 775 y ficheros 664. Podemos cambiar la máscara que está usando el usuario en ese momento mediante el comando umask, por ejemplo, ejecutar umask 077 en la sesión de Fernando haría que todos los ficheros creados a partir de ese momento por el se crearan con permisos 600 y todos los directorios con permisos 700. Este cambio sólo duraría mientras el usuario esté conectado, para hacer el cambio permanente tendríamos que modificar los ficheros nombrados anteriormente (/etc/profile o .bashrc_profile según nuestras necesidades) Para modificar los permisos de los archivos tenemos el comando chmod que puede ser usado de dos formas: mediante notación binaria o mediante el uso de caracteres. El comando se construye de la siguiente forma: chmod permisos directorio/archivo opciones

Si nos decidimos a usar el comando mediante el uso de caracteres hay que seguir el patrón usuario acción permisos u Usuario propietario del archivo. g Grupo propietario del archivo. o Otros usuarios. a Todo el mundo. + Añadir permisos. - Quitar permisos. = Sólo deja ese permiso. r Permiso de lectura. w Permiso de escritura. x Permiso de ejecución. Por ejemplo, si quisiéramos darle permisos a otros de lectura y ejecución sobre el directorio "virtual-root.eflZcm", el comando quedaría así: chmod o+rx virtual-root.eflZcm/ Ahora si hacemos un ls -l:

Vamos a quitarle los privilegios recién otorgados al directorio usando - en lugar de +: chmod o-rx virtual-root.eflZcm/ Si por el contrario preferimos trabajar en binario con el comando chmod deberemos hacerlo de la siguiente forma: Lo primero que hay que tener claro es que cada grupo de tres caracteres representa los permisos efectivos del propietario, del grupo y de otros respectivamente, por lo tanto cada grupo de tres será tratado independientemente. Los valores en binario corresponden a los siguientes: 0 _ _ _ 0: ningún permiso 1 _ _ x 1: permiso de ejecución 2 _ w _ 2: permiso de escritura 3 _ w x 3: permiso de ejecución + escritura (1+2) 4 r _ _ 4: permiso de lectura 5 r _ x 5: permiso de lectura + ejecución (4+1) 6 r w _ 6: permiso de lectura + escritura (4+2) 7 r w x 7: permiso de lectura, escritura y ejecución (4+2+1) Cada grupo de tres deberá tener un valor comprendido entre 0 y 7 incluidos a la hora de establecer los permisos. Así por ejemplo, si quisiéramos asignar todos los permisos al propietario, lectura y ejecución al grupo y lectura y ejecución a otros sobre el fichero virtual-root.ef1Zcm quedaría de la siguiente forma: chmod 755 virtual-root.eflZcm/ Mostrando los permisos:

Si quisiéramos dejarle los permisos como estaban, es decir, que el grupo y otros no tuvieran ningún privilegio, se haría de la siguiente forma: chmod 700 virtual-root.ef1Zcm/ Algunos de los parámetros que se le pueden pasar a chmod son: -R Cambia recursivamente los permisos de los archivos y directorios que haya debajo del directorio seleccionado. -v Saca una descripción de las acciones tomadas sobre cada fichero. -c Muestra una descripción de los ficheros a los que les hayan cambiado los permisos realmente. Para modificar el usuario propietario de un archivo existe el comando chown chown usuario archivo Algunos de los parámetros que se le pueden pasar a chmod son: -R Cambia recursivamente el propietario de los archivos y directorios que haya debajo del directorio seleccionado. -v Saca una descripción de las acciones tomadas sobre cada fichero. -c Muestra una descripción de los ficheros a los que les haya cambiado propietario realmente. Así pues, si quisiéramos cambiar el propietario del archivo "virtual-root.ef1Zcm" para que el nuevo fuera pepe, usaríamos el siguiente comando: chown pepe virtual-root.ef1Zcm/ Haciendo un ls -l:

Volvemos a dejarlo como estaba: chown root virtual-root.ef1Zcm/ También podemos modificar el grupo propietario de un archivo mediante el comando chgrp chgrp grupo directorio/archivo Algunos de los parámetros que se le pueden pasar a chmod son: -R Cambia recursivamente el grupo propietario de los archivos y directorios que haya debajo del directorio seleccionado. -v Saca una descripción de las acciones tomadas sobre cada fichero. -c Muestra una descripción de los ficheros a los que les haya cambiado grupo propietario realmente. Cambiemos, por ejemplo, el grupo propietario del fichero virtual-root.ef1Zcm a "pepe": chgrp pepe virtual-root.ef1Zcm/

Dejémoslo como estaba: chgrp root virtual-root.ef1Zcm/ Podemos cambiar el propietario y el grupo propietario a la vez mediante el comando chown. Por ejemplo si quisiéramos cambiar el propietario y el grupo del fichero virtual-root.ef1Zcm por pepe en ambos casos: chown pepe:pepe virtual-root.ef1Zcm/

Lo dejamos como estaba: chown root:root virtual-root.ef1Zcm/

En lugar de usar el nombre de los usuarios también podríamos utilizar su UID y GID respectivamente. Permisos especiales El primero de ellos es el "Sticky bit". Cuando el sticky bit está habilitado en un determinado directorio, todos los archivos que haya dentro de ese directorio sólo podrán ser eliminados por el usuario que los haya creado. Esto evita el problema de que cualquier usuario con permisos de escritura sobre un directorio pueda eliminar estos archivos. Para habilitar el sticky bit hay que añadir un 1 a los permisos normales. Por ejemplo, creamos un directorio que se llame sticky en /tmp: mkdir /tmp/sticky A continuación le asignamos permisos 755 al directorio y le asignamos el 1 del sticky bit: chmod 1755 /tmp/sticky Ahora si miramos los permisos del directorio: ls -l /tmp/sticky

Comprobamos que aparece una "t" en lugar de la x de ejecución en los permisos. A partir de ahora sólo el propietario de los archivos creados en ese directorio podrá borrarlos. El segundo tipo de permiso especial es el "bit sgid". El bit sgid se utiliza para establecer directorios colaborativos. Cuando un directorio tiene el bit sgid habilitado, cualquier archivo que se cree dentro de él pertenecerá al grupo propietario del directorio y no al del creador. Para habilitarlo basta con añadir un 2 a los permisos normales. Vamos a habilitar el bit sgid en el directorio sticky: chmod 2755 /tmp/sticky Ahora mostramos los permisos: ls -l /tmp/sticky

Se aprecia cómo ha desaparecido la "t" del sticky bit y ahora en los permisos del grupo aparece una "s" en lugar de la x de ejecución. Ahora todos los archivos que se creen dentro del directorio sticky pertenecerán al grupo propietario del directorio, es decir, root. El último tipo de permiso especial es el "bit suid". Cuando un archivo tiene habilitado el bit suid, cualquiera que ejecute dicho archivo lo hará con los mismos privilegios que el creador del mismo. Hay que tener mucho cuidado con este permiso porque por ejemplo, si el administrador crear un archivo y le asigna el bit suid, cualquiera que pueda ejecutar ese archivo lo hará con los mismos privilegios que el administrador. Para habilitarlo basta con añadir un 4 a los permisos normales. Vamos a crear un archivo en /tmp llamado suid: touch /tmp/suid A continuación le asignamos el bit suid: chmod 4755 /tmp/suid Comprobamos los permisos: ls -l /tmp/suid

Comprobamos que aparece una s en lugar de la x de ejecución en los permisos del propietario. El comando sudo En ocasiones es necesario proporcionar acceso a ciertas funciones del sistema propias del usuario root a otros usuarios que, de otra forma, no podrían ejecutar. Sudo proporciona acceso a otros usuarios a comandos sólo accesibles por root. Por ejemplo, si el usuario crear usuarios, intentaría ejecutar sudo /usr/sbin/useradd obteniendo el siguiente resultado tras introducir su contraseña:

Para otorgar privilegios mediante el comando sudo a los distintos usuarios, existe el fichero /etc/sudoers. Podemos modificar dicho fichero mediante el editor de texto que prefiramos sin embargo, la modificación suele realizarse mediante el comando visudo el cual lo edita con el editor por defecto que debería ser vi. Es recomendable utilizar el mandato visudo debido a que tiene dos grandes ventajas: Cuando se edita el fichero lo bloquea de tal manera que no pueda haber dos personas a la vez modificándolo y por lo tanto uno modifique el trabajo del otro. Una vez guardado el fichero, visudo comprueba la sintaxis del mismo y si detecta algún error en la misma no deja salir de él hasta que ha sido subsanado. El contenido del fichero sería como este:

Se pueden definir privilegios en el fichero /etc/sudoers siguiendo el siguiente patrón: usuario host=comando/s Si quisiéramos que el usuario pepe pudiera crear usuarios, editaríamos el fichero de la siguiente forma: visudo y añadiríamos la siguiente línea: pepe ALL=/usr/sbin/useradd Logueamos con el usuario pepe y probamos a crear un usuario: su - pepe sudo /usr/sbin/useradd pruebasudo cat /etc/passwd

Con el objetivo de agilizar la tarea podemos definir alias. Para crear un alias de usuarios usaríamos la siguiente sintaxis: User_alias NOMBRE_DEL_ALIAS = Usuarios Para crear un alias de host: Host_alias NOMBRE_DEL_ALIAS = hosts Finalmente, para crear un alias de comandos: Cmnd_alias NOMBRE_DEL_ALIAS = comandos Listas de acceso o ACLS En ocasiones, los permisos tradicionales que se le asignan a los distintos archivos se quedan cortos y es necesaria una mayor granularidad. Cuando queremos otorgarles privilegios a otros usuarios sobre un archivo sin tener que recurrir al grupo "otros" necesitamos utilizar las ACLS. Para que nuestro sistema trabaje con ACLS es necesario que la partición en cuestión esté montada con esa opción. Vamos a habilitar las ACLS en nuestro sistema para poder trabajar con ellas, para ello habrá que modificar la configuración del fichero /etc/fstab, añadir la opción y volver a montar la partición. Lo primero que hay que hacer es, igual que se hizo con las cuotas, modificar el fichero /etc/fstab y añadir la opción de las ACLS: joe /etc/fstab

Una vez que hemos agregado la opción, montamos de nuevo la partición: mount -a Ahora ya podremos utilizar ACLS en nuestro sistema. Existen dos tipos de ACLS, de acceso y por defecto. Una ACL de acceso es la que controla un directorio o archivo específico. Una ACL por defecto sólo puede establecerse en un directorio. Si los archivos dentro del directorio no tienen una ACL, usarán la ACL por defecto. El comando para establecer una ACL es setfacl, su sintaxis es la siguiente: setfacl parámetros reglas ficheros Algunos de los parámetros que se le pueden pasar son: -m Modifica o añade una ACL al directorio o archivo. -b Elimina cualquier ACL que existiera en el directorio o archivo. -d Modifica la ACL por defecto el directorio. -R Aplica los cambios de manera recursiva los subdirectorios y archivos. -k Elimina la ACL por defecto. -x Se eliminan los permisos de un usuario, grupo o de otros. La parte de las reglas debe ser de la forma: u:usuario:permisos Establece la ACL para un determinado usuario. Se puede especificar tanto su nombre como su UID. g:grupo:permisos Establece la ACL para un grupo dado. Se puede especificar tanto el nombre del grupo como su GID. o:permisos Establece la ACL para los demás usuarios. Para poder comprobar si un archivo o directorio tiene una ACL aplicada tenemos el comando getfacl, que tiene la siguiente sintaxis:

getfacl parámetros directorio o archivo Al comando getfacl se le pueden pasar, entre otros, los siguientes parámetros: -d Muestra la ACL por defecto -R Lista recursivamente las ACLS de todos los directorios y archivos. Para más parámetros, como siempre, man getfacl Para ver cómo funcionan las ACLS, creamos un archivo llamado "prueba" en /tmp con la cuenta de root: touch /tmp/prueba Miramos los permisos que tiene el archivo recién creado: cd /tmp ls -l

Comprobamos que el usuario es root y el grupo también es root. El usuario pepe entraría en el grupo "otros" y por lo tanto sólo podría leer el archivo creado por root. Vamos a hacer que pepe tenga permiso de escritura sobre el archivo mediante una ACL: setfacl -m u:pepe:rw prueba Ahora comprobamos cómo ha quedado la ACL: getfacl prueba El comando anterior debería producir una salida similar a la siguiente:

En donde comprobamos que pepe tiene permisos tanto de lectura como de escritura. Si listamos los permisos ahora: ls –l

Veremos que junto a los permisos efectivos aparece el símbolo "+" lo que indica que se está usando una ACL. Así pues, le hemos proporcionado permisos a pepe además de a root sin tener que meterlo en el saco de "otros". Gestión de permisos 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root. Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root: su – 2. Crea debajo de /tmp los directorios cpi, administracion y comercial. Creamos los directorios: mkdir /tmp/cpi mkdir /tmp/administracion

mkdir /tmp/commercial 3. Cambia el grupo propietario de cada directorio al correspondiente con su nombre. Comprueba que está correcto. Hacemos el cambio del grupo propietario en cada directorio: chgrp cpi /tmp/cpi chgrp administracion /tmp/administracion chgrp comercial /tmp/commercial Ahora comprobamos que cada directorio perteneces a su grupo: cd /tmp ls –l

4. Cambia los permisos de cada directorio (cpi, administracion, comercial) para que el propietario y el grupo propietario tengan todos los permisos y otros no tengan ninguno. Compruébalo. Establecemos los permisos conforme al enunciado: chmod 770 cpi chmod 770 administracion chmod 770 comercial Lo comprobamos: ls –l

5. Logueate con miguel e intenta crear un archivo en la carpeta comercial, ¿te deja? Nos logueamos con miguel: ssh miguel@127.0.0.1 Intentamos crear un archivo en /tmp/comercial: touch /tmp/comercial/archivo

No debería haberte dejado al usar miguel los permisos asignados a otros (ninguno) y no estar en el grupo comercial que es el grupo propietario de la carpeta. 6. Vuelve a usar la cuenta de root y haz que los archivos creados dentro las tres carpetas (cpi, administracion, comercial) pertenezcan al grupo propietario de cada una. Comprueba que se ha establecido correctamente. Para que los archivos creados dentro de cada directorio pertenezcan al grupo propietario debemos asignar permisos colaborativos, es decir, habilitar el bit sgid:

chmod 2770 /tmp/cpi chmod 2770 /tmp/administracion chmod 2770 /tmp/comercial Comprobamos que los permisos estén correctamente establecidos: ls –l

Vemos que aparece la s en lugar de la x de ejecución. 7. Utiliza la cuenta de gonzalo para crear un archivo dentro de la carpeta cpi, ¿a qué grupo pertenece? Nos conectamos como gonzalo: ssh gonzalo@127.0.0.1 Creamos el archivo dentro de cpi: touch /tmp/cpi/archivo Miramos a qué grupo pertenece: ls -l /tmp/cpi/archivo

Comprobamos que pertenece al grupo cpi. 8. Modifica la máscara de gonzalo para que los ficheros que cree a partir de ahora tengan permisos de lectura y escritura para el usuario y escritura para el resto y prueba a crear un nuevo fichero llamado mascara. ¿Qué permisos tiene? Prueba a crear un directorio llamado umask y comprueba qué permisos tiene. Los permisos sobre ficheros son 666, así que para que al propietario le queden permisos de lectura y escritura 6(rw_) y al resto sólo escritura 2(_w_), la máscara quedaría así: umask 044 Creamos el fichero: touch mascara Comprobamos los permisos: ls –l

Creamos el directorio llamado umask: mkdir umask Comprobamos los permisos: ls –l

El directorio tiene permisos 733 debido a que los directorios tienen permisos 777 antes de que se les aplique la máscara. 9. Modifica la máscara que tendrá por defecto gonzalo en cada inicio de sesión a partir de ahora por 044.

Modificamos la máscara por defecto para gonzalo en el fichero .bash_profile que está en su carpeta home: joe .bash_profile Añadimos al fichero:

Ahora si volvemos a loguear como gonzalo y comprobamos la máscara por defecto: ssh gonzalo@127.0.0.1 umask

10. Haz que gonzalo pueda, mediante sudo, modificar los datos de los usuarios. Prueba a modificar mediante la cuenta de gonzalo su propio uid por el 3000. Usamos la cuenta de root: su – Modificamos el fichero /etc/sudoers: visudo Añadimos la siguiente línea al final del fichero por ejemplo:

Para añadirlo en vi, usamos la "i" para insertar el texto y escribimos la línea anterior. Una vez hayamos acabado pulsamos "esc" y seguidamente ":x!" para salir guardando. Logueamos con gonzalo para probar a modificar su propio id por 3000: su - gonzalo Cambiamos su uid por 3000: sudo /usr/sbin/usermod -u 3000 gonzalo Comprobamos que ha cambiado correctamente: cat /etc/passwd | grep Gonzalo

11. Mediante una ACL, haz que el usuario ana no tenga permisos de escritura y ejecución dentro de la carpeta cpi. Comprueba que funciona correctamente. Creamos la ACL necesaria para que ana no pueda escribir en un directorio en el que en principio no debería tener problemas para ello: setfacl -m u:ana:r /tmp/cpi Logueamos como ana: su - ana Probamos a acceder con el usuario ana a /tmp/cpi: cd /tmp/cpi

ana pertenece al grupo cpi pero la ACL prevalece sobre ello. 12. Haz, mediante una ACL, que el usuario yolanda pueda leer y escribir dentro de la carpeta cpi. Compruébalo. Creamos la ACL: su – setfacl -m u:yolanda:rw /tmp/cpi Logueamos con el usuario yolanda:

su - yolanda Creamos un fichero dentro de /tmp/cpi: touch prueba /tmp/cpi Se crea sin problemas. 13. Comprueba las ACLs aplicadas al fichero /tmp/cpi. Comprobamos las ACLs de /tmp/cpi: su – getfacl /tmp/cpi

14. Elimina la ACL para el usuario ana. Compruébalo. Eliminamos la ACL para ana: setfacl -x ana /tmp/cpi Ahora si probamos a acceder al directorio con el usuario ana: su - ana cd /tmp/cpi No nos da ningún problema. En linux, los programas se instalan a través de un conjunto de paquetes. Estos paquetes incluyen todo tipo de archivos (librerías, ejecutables, páginas de manual y otra documentación) y son instalados mediante una serie de herramientas que varían según la distribución en la que estemos trabajando. Normalmente los paquetes se encuentran se encuentran alojados en servidores en internet, son los llamados repositorios. Los repositorios oficiales de cada distribución vienen configurados por defecto para que cualquier usuario pueda descargarse el software según sus necesidades y además podemos añadir otros repositorios no oficiales si lo deseamos. Estos paquetes pueden ser el propio código fuente de los programas o paquetes específicos para nuestra distribución listos para ser instalados. Si nos descargamos el código fuente de un programa hará falta compilarlo para que este funcione. Compilar consiste en procesar un fichero con diversas órdenes mediante un lenguaje de programación como C o Python para generar un fichero que pueda ser procesado por el sistema. Para que la tarea resulte más sencilla, normalmente estos paquetes vienen con un fichero llamado README o INSTALL en el cual se detallan las instrucciones necesarias para llevar a cabo la instalación. El otro tipo de paquetes, los que se descargan específicamente para cada distribución suelen llevar una extensión .rpm, .deb, etc según la distribución que usemos y son

gestionados e instalados por unas herramientas específicamente pensadas para ello lo que convierte la tarea en algo muy sencillo. El problema que ha existido siempre a la hora de instalar paquetes ha sido las dependencias que existen entre los distintos paquetes. Es posible que nosotros queramos instalar cierto software y para ello necesitemos un paquete, pero para que funcione, ese paquete necesita de otro paquete del cual depende y así sucesivamente. Esta tarea puede suponer un gran problema para el usuario porque necesita de una atención constante y resolver las dependencias no siempre resulta sencillo. Para solucionar esto, existen las herramientas de gestión de paquetes que, hoy en día, resuelven las dependencias sin ningún problema facilitando enormemente la labor al usuario. Aquí nos vamos a centrar en los gestores de paquetes que utilizan Centos (basado en Red Hat Linux) y Ubuntu (basado en Debian) y más concretamente en los paquetes preparados explícitamente para cada distribución, dejando a un lado los que necesitan ser compilados a partir del código fuente. Por parte de Centos vamos a nombrar RPM y Yum mientras que por parte de Ubuntu vamos a citar dpkg, aptitude y el gestor de paquetes Synaptic. Gestor de paquetes RPM RPM (Red Hat Package Manager) fue desarrollado por Red Hat para su distribución Red Hat Linux pero su buen funcionamiento hizo que fuera adoptado rápidamente por otras distribuciones como SuSE. RPM se utiliza para instalar, desinstalar, actualizar y verificar programas localmente. La estructura de un paquete rpm es la siguiente: paquete-version-release-arquitectura.rpm Versión: Número que identifica el estado de desarrollo de un paquete. Release: Cambios en el paquete (actualizaciones, soluciones a problemas de seguridad…) Arquitectura: Procesador y otros componentes físicos sobre los que trabaja nuestro sistema. Normalmente, dentro de cada paquete hay archivos binarios, documentación, ficheros con configuraciones por defecto, log de los cambios sobre el paquete… Para llevar a cabo la tarea de instalación, realiza una serie de operaciones como son: Verificar las dependencias de los paquetes que deseamos instalar, de tal manera que si el paquete que vamos a instalar necesita de otro, nos avisa de que para instalarlo necesitamos tener previamente el otro. Comprueba los posibles conflictos entre paquetes como por ejemplo que estemos instalando una versión más vieja de un paquete que ya tenemos instalado. A la hora de instalar una versión nueva reemplaza los archivos de ese paquete salvo los de configuración. Si el archivo de configuración que existe actualmente ha sido modificado con respecto al original, RPM lo deja como está. Si el archivo no fue modificado lo reemplaza con el nuevo que se acaba de descargar. Si el nuevo archivo nuevo necesita ser instalado, el archivo de configuración existente se renombra a .rpmsave o .rpmnew Extrae los archivos del paquete y lo ubica en el sitio correcto dentro del sistema asignando además los privilegios necesarios para que funcionen

correctamente. Guarda una traza de todas las operaciones que se han hecho con los paquetes de manera que estas pueden ser consultadas posteriormente. A la hora de eliminar paquetes: Comprueba que ningún otro paquete dependa de ese y de ser así elimina el paquete. Revisa los archivos pertenecientes a ese paquete y si no son usados por ningún otro paquete los elimina. Elimina cualquier traza que pueda quedar de ese paquete en la base de datos RPM. El uso de rpm es muy sencillo, la sintaxis del comando es la siguiente: rpm parámetros nombre de paquete -i Instala el paquete en cuestión -F Actualiza el paquete a una versión más nueva si existe una versión antigua del paquete. Si no existe una versión antigua del paquete que se está instalando, no se instalará. -U Se comporta como –F si existe una versión antigua del paquete a instalar y si no se comporta como –i -e Elimina el paquete escogido. -v Presenta información del proceso de instalación a medida que este avanza. -V Verifica el paquete instalado comparándolo con la base de datos de rpm y muestra las diferencias que aprecie. --changelog Muestra información sobre los cambios que ha sufrido ese paquetes a lo largo del tiempo. --last Muestra los paquetes ordenados según fecha de instalación (los últimos primero) También podemos hacer consultas mediante los siguientes parámetros: -q Nos muestra el nombre del paquete y la versión. -qa Nos muestra todos los paquetes instalados. -qf Nos muestra el paquete propietario del archivo especificado. -qi Muestra información general sobre ese paquete. -ql Muestra todos los archivos correspondientes a ese paquete. Estas son sólo algunas de las opciones, como siempre para más opciones consultar la página man del comando en cuestión, en este caso man rpm Gestor de paquetes Yum Yum (Yellow Dog Updater Modified) es una herramienta de gestión de paquetes para sistemas basados en RPM. Fue desarrollada con la intención de resolver las dependencias que RPM no podía solucionar. Es una herramienta que se utiliza mediante línea de comandos, sin embargo hay una serie de aplicaciones como “pup” o “yumex” que lo otorgan de una interfaz gráfica simplificando bastante su uso. Realiza las tareas de instalación, desinstalación y actualización de paquetes al igual que RPM pero resuelve las dependencias haciendo el proceso de instalar software mucho más sencillo. A la hora de instalar un paquete, yum comprobará si ese paquete necesita de otros y en caso afirmativo los instalará. Lo mismo pasa a la hora de desinstalar software. Yum comprobará si algún otro paquete se instaló como dependencia del que se está desinstalando y en caso afirmativo, si ningún otro paquete necesita de esos otros paquetes los desinstalará.

En caso de que alguno de esos paquetes sea usado por otro paquete, no se desinstalará. Podemos añadir nuevos repositorios a los ya existentes en la red. Esto se consigue añadiendo un nuevo archivo en /etc/yum.repos.d/ con el mismo formato que los que ya se encuentran en ese directorio. Si mostramos el contenido de uno por ejemplo, veremos segmentos como el siguiente:

Tanto el campo que va entre corchetes como “name” indican descripciones del nuevo repositorio. En baseurl podemos especificarle la ubicación física del repositorio. En este caso se trata de uno local, pero podríamos especificarle una dirección en internet mediante una URL o bien un ftp. El campo gpgcheck indica si se debe comprobar que los paquetes estén firmados digitalmente, si es 1 se comprobará, si no no. El campo enabled establece si el repositorio está habilitado o no, si está a 1 estará habilitado y si está a 0 deshabilitado. Además de los repositorios existentes en la red, yum nos permite crear nuestros propios repositorios. Podemos crear un directorio que contenga los paquetes, hacerlo accesible vía http o ftp e instalando el paquete “createrepo”, hacer que ese directorio tenga los ficheros necesarios para funcionar. La sintaxis de yum es la siguiente: yum parámetros acción nombre del paquete Algunas de las acciones que se le pueden pasar son las siguientes: install Instala el paquete seleccionado. localinstall Instala el paquete desde un repositorio ubicado en el sistema local. groupinstall nombre del grupo de paquetes Instala el grupo de paquetes seleccionado. Un grupo de paquetes es un conjunto de software que aporta ciertas funcionalidades como por ejemplo funciones de impresión. remove nombre de paquete Elimina el paquete especificado. update nombre del paquete Busca actualizacones del paquete especificado. En el caso de no especificar ningún paquete, busca actualizaciones de todos. list (installed|available|updates) lista los paquetes instalados, disponibles o las actualizaciones según se le especifique. search patrón de paquete Lista todos los paquetes que se ajusten al patrón establecido. info nombre del paquete Muestra información detallada del paquete en cuestión. Algunos de los parámetros serían los siguientes: -y Especifica la opción yes por defecto antes de instalar un paquete. -q No muestra el progreso en pantalla. -v Muestra el progreso de manera más detallada. Vamos a dotar a yum de un entorno gráfico para hacer que sea más fácil trabajar con el. Para ello vamos a instalar el paquete yumex.

Nos abrimos una terminal desde la propia máquina o accedemos vía putty a la máquina Centos. Vamos a decirle a yum que busque paquetes relacionados con yumex: yum search yumex

Después de buscar, nos dice que ha encontrado un paquete con esas características llamado “yumex.noarch” y nos dice que es una extensión gráfica para yum. Si quisiéramos más información sobre el paquete: Yum info yumex.noarch

Como se puede apreciar, aparece el tamaño, la release, la URL… Procedemos a instalar el paquete: yum install yumex-noarch Conforme avance la instalación nos avisará del progreso y llegado un determinado punto nos mostrará las dependencias de ese paquete y el tamaño que va a ocupar entre otras cosas. También nos preguntará si deseamos instalar lo, le damos a “y” y al enter.

Ya tenemos instalado el paquete en nuestra máquina. Ahora vamos a iniciar el terminal de la máquina virtual para probarlo. Escribimos “yumex” en el terminal y nos aparecerá la siguiente pantalla. Gestor de paquetes dpkg Dpkg (abreviatura de Debian Package) es el sistema de gestión de paquetes creado por el proyecto Debian en el año 1993. El gestor es utilizado para instalar, desinstalar y manipular los paquetes .deb Es la base de los sistemas gestores de paquetes para sistemas basados en Debian y es en sí misma una herramienta de bajo nivel que precisa de otras más avanzadas como apt para traer los paquetes desde sitios remotos y resolver las dependencias que existen entre los distintos paquetes. A la hora de instalar un paquete realiza los siguientes pasos:

Extrae los ficheros de control del nuevo paquete. Si existe otra versión del mismo paquete en el sistema se ejecuta un script de pre-eliminación del antiguo paquete. Se ejecuta el script de pre-instalación del nuevo paquete. Se desempaquetan los nuevos ficheros y se crea una copia de seguridad de los antiguos por si la instalación fallara. Si existiera otra versión del paquete que se está instalado se ejecuta el script de post-eliminación del paquete antiguo. Se configura el nuevo paquete. La sintaxis del comando dpkg es la siguiente: dpkg parámetros acción nombre de paquete Algunos de los parámetros que se le pueden pasar son los siguientes: -B Desconfigurará los paquetes que dependan del paquete eliminado. -G No instala un paquete del que ya existe una versión más nueva en el sistema. -E Evita la instalación de un paquete si la versión que se está instalando es la misma que la que ya está instalada. Algunas de las acciones que se le pueden pasar son las siguientes: -i Instala el paquete especificado. -r Elimina el paquete y todos sus archivos, excepto los de configuración. Esto puede ser útil si se instala más tarde el mismo paquete. -P Elimina el paquete y todos sus archivos incluidos los archivos de configuración. -l Lista todos los paquetes instalados en el sistema. -L Muestra los ficheros instalados en el sistema que pertenecen al paquete especificado. Gestor de paquetes aptitude Apt (Advanced Packaging Tool) es un sistema de gestión de paquetes que nació gracias al proyecto Debian. Realmente apt no es un programa en sí sino un conjunto de funciones en C++ que es utilizado por otros programas en la tarea de distribución de paquetes. Uno de estos programas es apt-get, una herramienta que permite instalar, desinstalar y actualizar el software mediante una serie de comandos. Apt-get fue muy utilizado en su momento pero actualmente se está viendo reemplazado por otras herramientas de mejor funcionamiento como es aptitude. Aptitude es una herramienta de gestión de paquetes basada en apt-get pero que incorpora un entorno gráfico que hace que la tarea de instalación de paquetes resulte mucho más sencilla sobre todo a usuarios sin grandes conocimientos. Aptitude utiliza apt para realizar estas tareas y para llevarlas a cabo mantiene actualizada la lista de paquetes de debian que se encuentran en los repositorios en internet. La mejor virtud de aptitude es, que a diferencia de apt-get, gestiona de manera eficaz las dependencias existentes entre los distintos paquetes de tal forma que si al instalar un paquete, este depende de otro, lo instalará de manera automática. Esta ventaja se aplica también a la hora de desinstalar software.

Los repositorios utilizados tanto por aptitude como apt-get se encuentran en el archivo /etc/apt/sources.list y es aquí donde podemos añadir nuevos repositorios no oficiales a los ya existentes. Como se aprecia en ese archivo, hay varios tipos de repositorios: Main: Aquí se encuentra el software libre con actualizaciones de seguridad y soporte por parte de Ubuntu. Universe: Contiene software sin ningún tipo de soporte que es desarrollado por la comunidad. Si consiguen el apoyo de desarrolladores que se encarguen de mantenerlo actualizado y de proporcionar soporte puede llegar a pasarse al repositorio universe. Multiverse: Licencias no necesariamente libres. Es responsabilidad del usuario cumplirlas. Restricted: Software de pago que usualmente es mantenido por Ubuntu. Para instalar software mediante línea de comandos se utiliza la siguiente sintaxis: aptitude parámetros acción nombre de paquete Algunos de los parámetros que se le pueden pasar son los siguientes: -f Intenta arreglar las dependencias de paquetes “rotos” -r Trata las recomendaciones como dependencias a la hora de instalar paquetes nuevos. -s Simula las acciones introducidas en la línea de comandos sin llevarlas a cabo realmente. -d Descarga los paquetes pero no los instala ni los elimina. Algunas de las acciones que se le pueden pasar son las siguientes: install Instala el paquete elegido. remove Elimina el paquete elegido y todas las dependencias que no sean usadas por otro paquete en el sistema. update Actualiza la lista de paquetes disponibles desde los repositorios. search Busca paquetes que coincidan con el patrón de paquete especificado. show Nos muestra información sobre el paquete en cuestión. Además de usar aptitude mediante la línea de comandos, podemos usarlo como herramienta gráfica escribiendo aptitude tras lo cual aparecerá lo siguiente:

Una vez en esta pantalla podremos pinchar con el ratón en los diferentes menús que aparezcan hasta dar con el paquete que buscamos y cuando queramos instalarlo pulsaremos “g”. En la ventana de abajo aparece la descripción sobre el paquete o grupo de paquetes que estemos instalando. Las opciones manejadas por este gestor gráficamente son muchas e implican bastante complejidad, normalmente utilizaremos la línea de comandos antes que la interfaz gráfica. Gestor de paquetes Synaptic El gestor de paquetes Synaptic es una herramienta muy potente con interfaz gráfica que permite instalar, actualizar y desinstalar paquetes de forma muy sencilla y que resuelve las dependencias entre los distintos paquetes de forma eficaz. Su interfaz gráfica ofrece mucha información sobre los paquetes y asegura un control total de los mismos. Para acceder a la aplicación hay que ir a SistemaAdministraciónGestor de paquetes Synaptic Gestión de paquetes en Centos 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root.

Nos conectamos a la máquina virtual Centos vía putty o a través de la propia terminal de la máquina y utilizamos la cuenta de root: su -

2. Utiliza rpm para conocer qué archivos se encuentran en el paquete evince.

Comprobamos los archivos que se encuentran en el paquete evince: rpm -ql evince

3. Obtén información sobre el paquete evince mediante rpm.

Para obtener información sobre el paquete evince utilizaremos el siguiente mandato: rpm -qi evince

4. Mediante rpm, comprueba qué paquete es el que provee el fichero /etc/httpd/conf/httpd.conf

La consulta para obtener qué paquete provee /etc/httpd/conf/httpd.conf sería la siguiente: rpm -qf /etc/httpd/conf/httpd.conf

5. Saca un listado de los paquetes que contienen "dns" en su nombre mediante rpm.

Sacamos el listado de los paquetes instalados mediante rpm -qa y filtramos por dns: rpm -qa| grep dns

También se podría hacer de esta manera: rpm -qa '*dns*'

6. Comprueba si el paquete evince ha sufrido cambios desde que fue instalado mediante rpm. Comprobamos si ha sufrido cambios el paquete evince verificándolo:

rpm -V evince No nos devuelve nada, lo que quiere decir que no ha sido modificado. 7. Elimina el directorio /usr/share/doc/evince-0.6.0 y comprueba ahora si el paquete evince ha sufrido cambios.

Eliminamos el directorio /usr/share/doc/evince-0.6.0 rm -rf /usr/share/doc/evince-0.6.0

Comprobamos si ha cambiado el paquete evince: rpm -V evince

Tal y como se aprecia, nos informa de directorios y archivos que faltan. 8. Reinstala el paquete evince mediante yum y comprueba si está intacto. Reinstalamos el paquete mediante yum: yum reinstall evince Comprobamos si el paquete está intacto: rpm -V evince No nos devuelve ningún fallo, por lo tanto el paquete se encuentra intacto con todos sus archivos. 9. Comprueba las actualizaciones que ha sufrido el paquete evince mediante rpm.

Lo comprobamos: rpm -q --changelog evince

Comprobamos que se ha actualizado múltiples veces incluyendo actualizaciones de seguridad entre otras cosas.

10. Muestra los últimos paquetes instalados en el sistema mediante rpm.

Mostramos los últimos paquetes instalados, debido a que la salida que produce es muy larga, la paginamos mediante less: rpm -qa --last | less

Para salir, presionamos :q

11. Muestra mediante rpm los ficheros de configuración del paquete httpd-2.2.3-43.el5.centos.3

Mostramos los ficheros de configuración: rpm -qc httpd-2.2.3-43.el5.centos.3

12. Utiliza rpm para mostrar la documentación que posee el paquete httpd-2.2.3-43.el5.centos.3

Miramos la documentación que acompaña al paquete: rpm -qd httpd-2.2.3-43.el5.centos.3

13. Muestra todos los paquetes instalados en el sistema mediante rpm.

Mostramos todos los paquetes instalados: rpm -qa | less

14. Elimina la caché de yum para que pueda volver a leer los datos de los repositorios.

Limpiamos la cache: yum clean dbcache

15. Mediante yum, obtén un listado de las actualizaciones disponibles.

Mostramos las actualizaciones disponibles: yum list updates

16. Muestra todos los paquetes instalados en el sistema mediante yum.

Mostramos todos los paquetes instalados: yum list installed

17. Instala todas las actualizaciones disponibles mediante yum.

Instalamos todas las actualizaciones disponibles: yum update

18. Busca un paquete llamado zsh mediante yum.

Buscamos el paquete: yum search zsh

19. Muestra información sobre el paquete zsh.i386 mediante yum.

Obtenemos información sobre el paquete: yum info zsh.i386

20. Utilizando yum, instala el paquete zsh.i386.

Instalamos el paquete:

yum install zsh.i386

21. Obtén un listado de los grupos de paquetes que están disponibles para instalar mediante yum.

Obtenemos el listado de los grupos de paquetes disponibles: yum grouplist Aparecerán dos grupos, los instalados (installed) y los disponibles (available). 22. Instala el grupo de paquetes "KVM" utilizando yum. Instalamos el grupo de paquetes "KVM": yum groupinstall kvm

23. Busca los paquetes que tengan "dns" en su nombre mediante yum.

Buscamos paquetes con "dns" en su nombre: yum search dns

(salida omitida parcialmente)

24. Mediante yum, comprueba qué paquete provee el fichero /etc/joe/jpicorc

Comprobamos qué paquete provee /etc/joe/jpicorc: yum provides /etc/joe/jpicorc

25. Desinstala el paquete "autofs.i386" mediante yum.

Desinstalamos el paquete autofs.i386: yum remove autofs.i386

26. Utiliza el entorno gráfico de yum para actualizar el paquete "nfs-utils"

Utilizamos el entorno gráfico para desinstalar el paquete nfs-utils: Utilizamos el terminal de la máquina virtual y accedemos al entorno gráfico: yumex En la sección updates, seleccionamos el paquete nfs-utils y le damos a "procesar cola":

Nos saldrá una ventana como la siguiente:

Le damos a OK

Nos informa de que se ha actualizado correctamente. 27. Mediante el entorno gráfico de yum, busca el paquete "telnet-server" e instálalo. Buscamos el paquete "telnet-server". Pinchamos en la sección "available" y en la barra de debajo escribimos telnet-server y le damos a buscar.

Ahora seleccionamos el paquete y le damos a "procesar cola".

Nos informa de que el paquete en cuestión tiene dependencias, en concreto el paquete xinetd. Le decimos que los instale dándole a OK.

Nos informa de que se ha instalado correctamente. Gestión de paquetes en Ubuntu 1. Conéctate a tu máquina virtual Ubuntu y utiliza la cuenta de root.

Nos conectamos a la máquina virtual Ubuntu vía putty o a través de la propia terminal de la máquina y utilizamos la cuenta de root: su -

2. Muestra todos los paquetes instalados en el sistema mediante dpkg.

Mostramos todos los paquetes instalados: dpkg -l | less

3. Muestra todos los paquetes que contengan la palabra "sys" mediante dpkg.

Mostramos todos los paquetes que contengan la palabra "sys": dpkg -l '*sys*'

También se podría hacer así: dpkg -l | grep sys 4. Mediante dpkg, muestra los archivos que instala el paquete wget. Mostramos los paquetes que instala el paquete wget: dpkg -L wget

5. Comprueba qué paquete instala el fichero /etc/bind/db.root usando dpkg.

Comprobamos el paquete que instala /etc/bind/db.root: dpkg -S /etc/bind/db.root

Lo instala el paquete bind9.

6. Muestra el estado del paquete lsof mediante dpkg.

Mostramos el estado del paquete lsof: dpkg -s lsof

Nos dice que el paquete está instalado, cuánto ocupa, etc.

7. Muestra la lista de parámetros de dpkg.

Mostramos los comandos disponibles: dpkg -h

o bien: dpkg --help Se mostrará una lista con las acciones disponibles y también los parámetros. 8. Elimina el paquete nano, así como sus ficheros de configuración mediante dpkg.

Eliminamos el paquete nano así como sus ficheros de configuración: dpkg -P nano

9. ¿Qué opción usaríamos si quisiéramos eliminar nano pero mantener sus ficheros de configuración?

La opción que usaríamos sería: dpkg -r

10. Comprueba que el paquete nano ya no se encuentra instalado mediante dpkg.

Lo comprobamos: dpkg -l | grep nano

No nos devuelve nada por lo que el paquete no se encuentra instalado. 11. Actualiza la lista de paquetes disponibles mediante aptitude. Actualizamos la lista de paquetes: aptitude update Se leerán los repositorios en busca de actualizaciones y nuevos paquetes.

12. Utilizando aptitude, busca los paquetes que contengan screen en su nombre.

Buscamos los paquetes que contengan "screen": aptitude search screen Se mostrarán varios resultados junto con su descripción en el margen derecho de la pantalla. 13. Instala el paquete screen mediante aptitude. Instalamos el paquete screen: aptitude install screen

14. Muestra información sobre el paquete nano usando aptitude.

Mostramos información sobre el paquete nano: aptitude show nano

15. Busca alguna causa por la que el paquete wget debería ser instalado por dependencias con otro paquete mediante aptitude.

Preguntamos mediante aptitude: aptitude why wget

Nos dice que ubuntu-standard depende de wget y por lo tanto es necesario

16. Vacía la cache de aptitude.

Vaciamos la caché: aptitude clean

17. Muestra el log de cambios que ha sufrido el paquete wget mediante aptitude.

Mostramos el log de los cambios que ha sufrido wget: aptitude changelog wget Comprobamos que ha sufrido varias modificaciones de seguridad entre otras. 18. Muestra la lista de parámetros que se le pueden pasar a aptitude. Mostramos la lista de parámetros: aptitude -h Esto sacará por pantalla una lista de las acciones y los parámetros que se le pueden pasar al comando.

19. Simula mediante aptitude la instalación del paquete nano.

Simulamos la instalación: aptitude -s install nano

Nos muestra el espacio que necesitará entre otras cosas.

20. Descarga los paquetes necesarios para instalar "traceroute" pero sin instalarlo usando aptitude.

Descargamos los paquetes necesarios para instalar traceroute: aptitude -d install traceroute

Si buscamos si está instalado traceroute mediante dpkg -l | grep traceroute veremos que no, símplemente se ha descargado.

21. Inicia el gestor de paquetes Synaptic en tu máquina virtual Ubuntu.

Iniciamos el gestor de paquetes escribiendo synaptic en la terminal de la máquina o bien a través de Sistema Administración Gestor de paquetes Synaptic

22. Actualiza la lista de paquetes del gestor Synaptic.

Actualizamos la lista de paquetes:

Utilizamos la opción Recargar del gestor de paquetes Synaptic para actualizar la lista de paquetes:

23. Utilizando el filtro "estado", busca un paquete llamado snmp e instálalo.

Utilizamos el filtro "estado": En la parte superior elegimos "No instalados": A continuación en la barra superior buscamos "snmp": En la lista que aparece debajo, seleccionamos el paquete "snmp" y seleccionamos "marcar para instalar": Una vez marcado, le damos a "aplicar" para instalar el paquete:

24. Actualiza el paquete dpkg mediante Synaptic. Para actualizar dpkg seleccionamos el filtro "estado": Y en la parte superior elegimos "instalados (actualizables)": Ahora en el buscador escribimos "dpkg": Hacemos clic derecho sobre el paquete y le damos a "marcar para actualizar": Finalmente le damos a aplicar: Procesos y servicios Cuando trabajamos con cualquier tipo de sistema operativo, cualquiera de los objetos que se nos presentan en pantalla, están ahí gracias a que hay uno o varios procesos que se están ejecutando. Así pues, un proceso no es más que un programa en ejecución. Sin estos procesos en constante ejecución, sería imposible poder manejar el sistema operativo. En Linux, los procesos se ejecutan de una forma jerárquica, esto quiere decir que existe un proceso padre que lanza cada proceso hijo. En Linux el proceso padre es el init debido a que este es el primero que se ejecuta cuando arranca el sistema. Cuando se termina un proceso padre, se terminan también los procesos hijos que dependen de él. Linux es un sistema multitarea, lo cual quiere decir que puede ejecutar muchos procesos a la vez sin que unos interfieran con otros. Si quisiéramos ejecutar un mismo programa desde varios equipos a la vez, se generarían tantos procesos como equipos están ejecutando el programa. Un programa es un conjunto de comandos almacenados en un fichero ejecutable y que genera uno o varios procesos cuando es utilizado. Cada proceso va identificado mediante un indicador único que lo distingue unívocamente del resto, a este identificador de proceso se le llama PID. Existen dos tipos de procesos:

Procesos de usuario: Es un proceso iniciado por un usuario que ha hecho login mediante una terminal o mediante el entorno gráfico.

Procesos demonio (daemon): Es un proceso del sistema que no ha sido iniciado por ningún usuario y espera a que ocurra un evento (una conexión a través de la red por ejemplo) para ejecutar una determinada acción.

NIVELES DE EJECUCION (RUNLEVELS) El kernel ejecuta init al arrancar. Este programa, ahora como proceso, cargará los subprocesos necesarios para la puesta en marcha del sistema. Cuando init ha terminado de cargarse vacía el subdirectorio /tmp y lanza getty que se encarga de permitir hacer login en el sistema a los usuarios. Los niveles de ejecución (runlevel), definidos en el archivo /etc/inittab determinan los servicios que tendremos disponibles en cada uno de ellos. Es una forma de tener diferentes modos de trabajo, cada uno de ellos con características bien definidas, en función del tipo de tarea a que estén orientados. Existen ocho niveles de ejecución, que están numerados del cero al seis, más otro denominado con la letra “S” (tiene un alias con la letra “s”, que realmente es igual a el nº 1). Los niveles de ejecución de ejecución que manejaremos y una descripción de para qué están definidos se puede ver en la siguiente tabla: Nivel de ejecución Modo 0 Detener el sistema 1 Mono usuario, sin soporte de red, Mantenimiento 2 Multiusuario, sin soporte de red, Poco sistemas lo usan 3 Modo multiusuario completo 4 Sin uso. Recomendado para pruebas 5 Modo X11; Multiusuario completo en entorno gráfico 6 Reiniciar el sistema s/S Nivel Usuario Unico a/b/c Pseudo Estados (Casi nunca usado) Init necesita un archivo de configuración para saber exactamente lo que tiene que hacer. Este archivo es /etc/inittab y contiene información sobre el nivel a ejecutar por defecto, previsión sobre lo que hacer ante determinadas situaciones, describe qué procesos se inician en la carga y durante la operación normal. Utilice /sbin/runlevel para ubicarse en el actual runlevel que se encuentra: # /sbin/runlevel N 5 # shutdown -r -t 60 clean reboot in 60 seconds En el modo de single-user, solo /, /var y /boot son montados y solo procesos esenciales son ejecutados. Cambiar de Runlevel Se utilizan los comandos telinit o INIT para cambiar de runlevels. Ejemplo Talvez uisiese cambiar de single-user a multiuser o vice-versa. También puedes utilizar el comando shutdown para detener el sistema. Este avisa a los usuarios que el sistema esta a punto de apagarse. Aquí unos ejemplos del comando init: # init 2 Cambiar al runlevel 2 # init 5 Ahora cambiamos al runlevel 5 # shutdown

Apagar el sistema Es de extrema importancia que nunca apagues tu sistema de linux incorrectamente. Las razones son muchas pero aquí unas cuantas: • Si es un server pueden haber usuarios accesando la red • Pueden haber trabajos en el background o segundo plano • Actividad de disco de E/S y los buffered no sean transferidos lo cual corrompe el sistema de archivos. El proceso de init gerencia todo el sistema Linux. El lee información desde un archivo de control llamado /etc/inittab del cual usa la información para manejar los diferentes niveles de ejecución. Init también se utiliza para cambiar entre los diferentes runlevels. El /etc/inittab se utiliza para determinar cuales comandos ejecutar en cuales niveles. Los cambios de niveles son controlados por los archivos (rc) que ejecutan los diferentes comandos de ese nivel. El archivo rc a ejecutar en cada nivel esta definido en el /etc/inittab. El comando init acepta parámetros que es numérico indicando el nivel de ejecución a iniciar o uno de los siguientes: init s Modo de Single-user (También S es reconocida) init q Leer nuevamente el archivo /etc/inittab (También Q es reconocida) Cambiar a un runlevel mas alto es razonable pero a uno menor que el actual es peligroso, recuerde que existen aplicaciones, utilidades y servicios ejecutándose que probablemente terminaran sin avisar. Por ejemplo el nivel 0 es una manera imprudente de apagar ya que no avisa a los usuarios en sesión en el sistema que se esta a punto de apagar todo. Archivo de Control del Inicio: /etc/inittab El archivo /etc/inittab contiene la descripción general del proceso de arranque del sistema. Al terminar de cargarse el kernel, se llama al programa /sbin/init, que es el proceso padre de todos los demás procesos existentes en el sistema. init sigue las instrucciones incluidas en inittab para llevar al sistema a un estado usable, creando los procesos descritos en este archivo. Un runlevel (o nivel de ejecución) es una configuración por software del sistema que permite existir sólo a un grupo seleccionado de procesos. El sistema (por medio de init) está en cada momento en un runlevel concreto. El superusuario puede cambiar el runlevel en cualquier momento ejecutando telinit. Si efectua cambios al archivo inittab no es necesario para que los cambios surjan efectos, sólo deberá ejecutar el siguinete comando: # init q o # telinit q Estos comandos le ordenan a a init que lea su archivo de configuración sin cambiar de runlevel. El comando telinit es un vínculo a init en las mayoría de distros de GNU/Linux de hoy día. Hay ocho runlevels, llamados 0, 1, 2, 3, 4, 5, 6 y S. El runlevel 0 se usa para parar el sistema, el 6 para reiniciarlo y el S o el 1 para ponerlo en modo monousuario. Los demás niveles se utilizan para proporcionar determinado grado de servicios. Por ejemplo, es normal usar un nivel para el uso normal, otro para el arranque automático de XWindow, otro para uso sin red, etc.

Estructura del Archivo /etc/inittab Cada línea del archivo esta dividida en cuatros campos separados por dos puntos: Id: nivel: acción: proceso Campos Descripción ID Identificador unico de la línea hasta 4 caracteres alfanuméricos. Nivel Runlevel que activa este proceso indicado mas adelante Acción Palabra clave de cómo correr el proceso Proceso Nombre completo y parámetros del comando para ejecutar En la siguiente tabla se incluyen las palabras claves principales de acción del archivo inittab/ Campos Descripción Off No ejecute este comando Wait Ejecute este comando y espere que complete Once Ejecute este comando y no espere Respawn Ejecute este comando; y si falla, ejecutelo de nuevo Sysinit Ejecute el comando durante el primer init Boot Ejecutar el comando al tiempo de arranque y no espere Bootwait Como el Boot pero espere que complete Ctrlaltdel Ejecute el comando especificado al presionar estas teclas initdefault Define nivel de arranque por defecto Al iniciarse, init busca la línea initdefault en /etc/inittab para pasar al nivel por defecto. A continuación lee las demás líneas del archivo. Cada línea tiene la forma: Id: niveles: accion: procesos Donde id es una identificación para la línea, runlevels especifica los niveles en los que esta línea debe aplicarse, action es la acción que se va a realizar y Process es el proceso a ejecutar. El init va ejecutando los procesos especificados en las líneas que incluyan el nivel de ejecución actual. Cuando se cambia el nivel, los procesos del nivel antiguo son eliminados. Los procesos que se ejecutan en un estado normal son los scripts de arranque primero y las invocaciones a los programas que permiten a los usuarios usar el sistema después. Una de estas líneas podría ser como la siguiente: 1:2345:respawn:/sbin/getty 38400 tty1 Esta línea indica que en los niveles de ejecución 2,3,4 ó 5 debe ejecutarse el programa /sbin/getty (que es el programa que se encarga de pedir el login y el password a los usuarios) con los parámetros 38400 (que indica que espere comunicaciones a 38400 baudios), y tty1 (que indica que escuche en la primera terminal virtual). La palabra clave respawn indica que este proceso debe reiniciarse cuando termine, de forma que cuando un usuario salga del sistema, se vuelva a mostrar el prompt de login para aceptar otro usuario. Hay que manejar con cuidado el fichero inittab, ya que una modificación indebida del mismo puede dejar al sistema en un estado incapaz de arrancar. LOS SCRIPTS DE LOS NIVELES DE EJECUCION

Los sccripts de ejecución se encuentran en los directorios /etc/rc.d/rc*.d y son iniciados bajo la dirección del archivo /etc/inittab. Cada runlevel diferente contiene sus propios archivos scripts que se ejecutan al inicio de la sesión del runlevel. rc0 Busca en /etc/rc.d/rc0.d Para el nivel 0 Halt/apagado Rc1 Busca en /etc/rc.d/rc1.d Para el nivel 1 Single user/unico usuario Rc2 Busca en /etc/rc.d/rc2.d Para el nivel 2 Multiusuario, sin network Rc3 Busca en /etc/rc.d/rc3.d Para el nivel 3 Total multiusuario con soporte de redes Rc4 Busca en /etc/rc.d/rc4.d Para el nivel 4 Reservado, no se usa Rc5 Busca en /etc/rc.d/rc5.d Para el nivel 5 X11 (inicio gráfico, multiusuarios) Rc6 Busca en /etc/rc.d/rc6.d Para el nivel 6 Reboot/reinicio La mayoría de distribuciones dejan el nivel dos y el nivel cuatro para que el administrador introduzca sus propios scripts/guiones de inicio en este nivel /etc/rc.d/rc4.d / o el /etc/rc.d. El scripts busca en el directorio debajo del /etc/rc.d/init.d para scripts a ejecutar para los niveles de ejecución requeridos. Cada uno de estos directorios contiene vínculos a archivos almacenados en el /etc/init.d. Los nombres de los vínculos son referentes al orden predeterminado a ejecución de dos digitos. Nombres de scripts que empiezan con “S” son iniciado en su apropiado runlevel y los scripts que empiezan con “K” los detiene (killed). Cuando el scripts se invoca desde el programa rc, el primer parámetro esta colocado en la palabra “start” o “stop”. El script en /etc/rc.d/init.d debe buscar el valor de este parámetro para determinar que acción tomar (Start o el kill). Un proceso puede estar en uno de los siguientes estados: RUNNING: Significa que el proceso se está ejecutando en ese momento en la CPU o que está listo para ser ejecutado. SLEEPING: El proceso está esperando a que le llegue una señal para volver al estado RUNNING ZOMBIE: El proceso ha terminado pero su valor de retorno todavía no ha sido recogido, de modo que aún sigue apareciendo en la tabla de procesos.Puede deberse a que el proceso que lo inició (el llamado padre) ha muerto y no lo puede recoger. STOPPED: El proceso está detenido puede estar así por haber recibido una señal que le fuerce a ello. Todo proceso tiene dos atributos fundamentales: PID, que es el número que identifica de manera única a un proceso, y el PPID, que es el identificador del padre de un proceso (todo proceso es arrancado por otro, que es el padre). Para el control de procesos combinaciones de teclas muy útiles: Ctrl+C termina un proceso, y Ctrl+Z pone en pausa un proceso.

Comandos de gestión de procesos Si ejecutamos el comando top, veremos, de manera dinámica, los procesos que se están ejecutando y, entre otras cosas, su PID: top

Las columnas corresponden con lo siguiente: PID: Identificador único de cada proceso. USER: Usuario que ha lanzado el proceso. PR: Prioridad del proceso en el sistema. NI: Valor de “nice” del proceso. Contra más pequeño sea este número más prioridad tiene el proceso y viceversa. VIRT: Uso de memoria virtual del proceso. RES: Memoria RAM que utiliza. SHR: Cantidad de memoria compartida utilizada por el proceso. S: Estado del proceso. Puede ser: S: sleeping R: running T: stopped Z: zombie D: uninterruptible sleep Un proceso en estado sleep, está parado durante x tiempo y después se despierta y sigue ejecutándose. Un proceso en estado running se está ejecutando. Un proceso en stop, está pausado. Un proceso en estado zombie, es un proceso que ha completado su ejecución pero todavía aparece en la tabla de procesos y permite al proceso que lo ha creado leer el estado de su salida. Un proceso en estado uninterruptible sleep es el que no puede ser matado de ninguna forma. Suelen aparecer cuando ha habido algún problema a la hora de leer de algún medio defectuoso. %CPU: Porcentaje de uso de CPU. %MEM: Porcentaje de uso de memoria. TIME+: Tiempo que lleva el proceso ejecutándose. COMMAND: Nombre del proceso y comandos que le hayamos pasado. Podemos modificar las columnas que muestra top pulsando “f” una vez dentro del comando:

También podemos modificar el orden de las columnas pulsando “o” dentro del propio comando. Podemos salir de top pulsando “q”. Algunos de los parámetros que podemos pasarle a top son los siguientes: -d tiempo en segundos Establece el número de segundos que tarde en actualizarse top. Por defecto el tiempo son 3 segundos. -b Pasa a top a modo “batch” por si deseamos redirigir la salida a un fichero por ejemplo. -n número de iteraciones Hace que top se cierre automáticamente después de haberse refrescado el número de iteraciones que le hayamos asignado. Además del PID, cuando un proceso es lanzado desde la Shell, se le asigna un Job ID único que lo distingue del resto. Los procesos pueden lanzarse en primer plano (foreground) o en segundo plano (background). Cuando un proceso se lanza en primer plano, este se quedará ejecutándose hasta que acabe y, entonces, el usuario volverá a tener control en la Shell. Si un proceso se ejecuta en segundo plano, el proceso se ejecutará mientras el usuario sigue teniendo el control de la Shell. Podemos mandar procesos a segundo plano o traerlos a primer plano según consideremos oportuno. Podemos ver los procesos lanzados en 2º plano mediante jobs. Si lanzamos el proceso xeyes, por ejemplo desde la terminal de nuestra máquina virtual: xeyes Este se quedará ejecutándose en primer plano hasta que acabe. Podemos pausar el

proceso pulsando Control+z y ahora, escribiendo bg, lanzaremos el proceso en segundo plano. bg

Veremos que aparece: El 1 que aparece entre corchetes es el job ID y el & indica que el proceso se ha lanzado en primer plano. Podemos traer el proceso a primer plano de nuevo escribiendo fg y el job ID: fg 1 También podemos lanzar directamente un proceso en segundo plano escribiendo: Nombre de proceso & Con el comando ps podemos ver las características de los procesos que se están ejecutando en ese momento en el sistema. Si no se le pasa ningún parámetro se visualizan los procesos que han requerido de una terminal para ejecutarse. La sintaxis es: ps parámetros Algunos de los parámetros que se le pueden pasar son los siguientes: x Visualiza todos los procesos que se están ejecutándose en el sistema. u Visualiza un formato orientado al usuario. F Visualiza los procesos en forma de árbol. -u uid usuario Visualiza los procesos pertenecientes al usuario con el UID correspondiente. -l Visualiza los procesos en formato extendido. Mediante el comando pstree podemos mostrar los procesos ordenados en forma de árbol facilitando así la visión de los procesos padre e hijo y las dependencias entre ellos. La sintaxis del comando es: pstree parámetros El formato que muestra sería el siguiente:

Algunos de los parámetros que se le pueden pasar son los siguientes: -p Muestra los PID de los procesos. -Z Muestra el contexto de seguridad de cada proceso. -l Muestra cada línea en formato largo. -a Muestra los argumentos pasados por línea de comandos a cada proceso. Si queremos manipular el estado de un proceso podremos hacerlo mandándole señales, esto se consigue mediante el comando kill. La sintaxis del comando es: kill parámetros pid del proceso Con kill –l mostramos las señales que se le pueden pasar:

La señal por defecto es la de matar el proceso, es decir la número 9.

Algunos de los parámetros que se le pueden pasar son los siguientes: -p nombre de proceso Le dice q kill que sólo debe mostrar los PID de los procesos que concuerden con el nombre. -s número de señal Especifica la señal a enviar. Con el comando killall se consigue lo mismo que con kill sólo que en lugar de utilizar el PID del proceso como indicador se utilizar el nombre. Así, si tenemos varias instancias de Apache funcionando, por ejemplo, con el comando killall enviaríamos la señal a todas ellas. La sintaxis del comando es: killall parámetros nombre del proceso Algunos de los parámetros que se le pueden pasar son los siguientes: -i Pregunta interactivamente al usuario por cada proceso antes de matarlo. -s número de señal Envía esta señal en lugar de la de kill. -u nombre de usuario Mata sólo los procesos que haya lanzado el usuario especificado. -v Enseña un mensaje si la señal fue mandada con éxito. Podemos cambiar la prioridad de un proceso con los comandos nice y renice de tal forma que si necesitamos que un proceso en concreto pueda utilizar más recursos le incrementaremos la prioridad. Todos los procesos se lanzan con una prioridad por defecto de 0, sólo el usuario root puede establecer una prioridad más alta a 0. Los valores de la prioridad van desde -20 (que es la prioridad más alta) a 19. Para lanzar un proceso con una determinada prioridad utilizaremos la siguiente sintaxis: nice –n número de prioridad comando, programa… Así pues, si quisiéramos lanzar el programa xeyes con una prioridad de 5 en segundo plano lo haríamos así: nice –n 5 xeyes

De igual manera, para cambiar la prioridad de un proceso que ya se está ejecutando utilizaremos renice con la siguiente sintaxis: renice prioridad pid, pgrp, user Los parámetros que se le pueden pasar son los siguientes: -p Especifica el PID del proceso al que se le va a cambiar la prioridad. -u Se le cambiará la prioridad a los procesos que poseídos por dicho usuario. -g Todos los procesos del grupo especificado verán cómo se cambia su prioridad. Vamos a asignarle una prioridad de 4 al proceso que ya está lanzado: renice 4 –p 5804

Normalmente sólo asignaremos prioridades negativos a procesos que sean críticos para el sistema en el que estemos trabajando con el fin de que siempre tenga la máxima disponibilidad de recursos. Otra herramienta muy útil a la hora de trabajar con procesos es lsof.

lsof nos permite saber qué ficheros están abiertos actualmente en el sistema. Cuando no sabemos qué proceso tiene abierto un fichero, esta herramienta resulta de extrema utilidad. Es posible que no seamos capaces de llevar a cabo una determinada acción con un programa porque ese programa depende de un fichero que está siendo utilizado por otro proceso. Ahí es donde juega un papel importante lsof. La sintaxis del comando es la siguiente: lsof parámetros nombre Donde nombre puede ser un directorio, un fichero, un puerto… según el parámetro que le pasemos. Algunos de los parámetros que se le pueden pasar son los siguientes: +d nombre de directorio Busca los procesos que tienen abierto el directorio pero no desciende recursivamente por los subdirectorios. +D nombre de directorio Busca los procesos que tienen abierto el directorio y recursivamente todos los subdirectorios y archivos que hay por debajo. -i ip Lista los archivos que estén siendo usados por la dirección especificada. -p PID Lista los archivos que tienen abiertos los procesos con el PID seleccionado. -N Selecciona los archivos NFS. Para probar el comando, creamos un directorio llamado /tmp/pruebalsof y accedemos a él: mkdir /tmp/pruebalsof cd /tmp/pruebalsof Ahora comprobamos qué está usando el directorio en cuestión: lsof +D /tmp/pruebalsof

Otro comando muy útil a la hora de trabajar con procesos es screen. El commando screen nos permite crear tantos "terminales virtuales" como queramos, de tal forma que podemos lanzar procesos que van a tardar mucho rato en acabar en estos terminales virtuales mientras nosotros seguimos trabajando desde la terminal original. Además, esta herramienta tiene otra ventaja muy importante y es que, en el caso de que perdamos la conexión con la máquina en la que estamos trabajando vía ssh, la terminal creada mediante screen seguirá ejecutándose por lo que podremos conectarnos de nuevo, recuperar esa ventana y comprobaremos que el proceso ha seguido ejecutándose. Para ejecutarlo basta con escribir screen si lo tenemos instalado. Esto nos llevará a la terminal virtual en la que trabajaremos. Algunos de los controles de screen son los siguientes: control+a+d Nos desconecta de la terminal actual volviendo a otra terminal virtual en la que estuviéramos anteriormente o a la real. control+a+c Crea una nueva terminal virtual. control+a+n Cambiar a la siguienter terminal virtual. control+a+p Cambiar a la terminal anterior. screen -r Se conecta a la terminal que hayamos dejado abierta.

screen -x número de terminal Se conecta a la terminal virtual que nosotros le especifiquemos. screen -list Lista las terminales virtuales que se están ejecutando en ese momento. Para cerrar las terminales virtuales basta con escribir exit. Servicios Un servicio (también llamado daemon) es un proceso o conjunto de procesos que están continuamente esperando a un evento que desencadene una determinada acción. Por ejemplo el servicio ssh, que está continuamente escuchando en el puerto 22 hasta que le entre una conexión por ese puerto y establezca el túnel con el cliente. Otro ejemplo sería el servidor web, que está continuamente escuchando en el puerto 80 hasta que le entra una petición de una web y la sirve. No puede haber dos servicios escuchando en el mismo puerto. Además de los servicios normales, existen una serie de servicios que se necesitan menos frecuentemente que el resto. Estos servicios suelen estar deshabilitados de manera predeterminada y cuando alguien los necesita, son puestos en marcha por un servicio llamado xinetd. Podemos ver los puertos que utiliza cada servicio por defecto en el fichero /etc/services: cat /etc/services

Cuando trabajemos con servicios, muchos de ellos estarán orientados a ofrecer una serie de funciones a través de la red y, por lo tanto, utilizarán un puerto de la máquina que deberemos tener abierto para poder dar servicio. Dado que la cantidad de servicios que podemos llegar a tener activos es bastante grande, es necesario conocer qué puertos tenemos abiertos con el fin de evitar algún posible problema de seguridad. Para monitorizar qué servicios están usando cada puerto y poder comprobar las conexiones activas con nuestra máquina existe el comando netstat. Algunos de los parámetros que se le pueden pasar son: -a Muestra todas las conexiones y los puertos en escucha de la máquina. -c Saca por pantalla la información solicitada cada segundo de manera continua. -n Muestra la IP de las máquinas en lugar de intentar resolver el nombre de host al que van asociadas. -l Muestra sólo las conexiones que están escuchando en algún puerto. -p Muestra el PID y el nombre de cada programa que tenga abierta una conexión.

Los servicios trabajan en segundo plano y normalmente son iniciados por el propio sistema. No utilizan ninguna terminal, de ahí que al ejecutar un ps x, debajo de la columna TTY aparezca una “?” ps x| grep ssh

Los servicios o daemon se suelen reconocer porque normalmente su nombre acaba en “d” Para poder administrar los servicios, existen una serie de scripts en la ruta /etc/init.d que los controlan. La mayoría de estos scripts están programados de tal forma que el usuario puede interactuar con ellos mediante las órdenes: start Inicia el servicio. stop Detiene el servicio. restart Reinicia el servicio. status Muestra si el servicio está corriendo o no. Así pues, podríamos comprobar el estado del servicio sshd mediante: /etc/init.d/sshd status

Además, en ciertas distribuciones como Centos existe el comando service para poder administrar los servicios sin tener que escribir la ruta completa a la carpeta /etc/init.d. Por ejemplo: service sshd status Los servicios pueden configurarse para que arranquen junto con el sistema operativo y, al igual que este, se pueden iniciar en diferentes niveles de ejecución o runlevels. En linux existen (normalmente) 7 niveles de ejecución distintos, los cuales serían: 0 Apagado del sistema. 1 Modo monousuario o "single user". Se suele emplear para tareas de mantenimiento del sistema. 2 Modo multiusuario sin red. 3 Modo multiusuario con funciones de red. 4 No es utilizado. Se puede emplear para ser personalizado. 5 Modo multiusuario con entorno gráfico. 6 Reinicio del sistema. Cuando arranca el sistema, comprueba el contenido del fichero /etc/inittab e inicia el sistema en el nivel de ejecución que esté definido por defecto ahí.

En la captura de pantalla se aprecia que el nivel de ejecución por defecto es el 5 (initdefault) pero este podría ser cambiado según nuestras necesidades. Además, en este fichero se define también el runlevel que se le va a pasar al arrancar al script /etc/rc.d/rc tal y como se aprecia en la captura de pantalla. Una vez que recibe este argumento, se va al directorio /etc/rcX.d/ donde X es el nivel de ejecución que se le ha pasado anteriormente. En ese directorio hay unos enlaces simbólicos a los scripts de /etc/init.d/ que debe ejecutar. Por ejemplo si listamos el contenido de /etc/rc5.d/, para el nivel de ejecución 5 tendríamos lo siguiente:

En ese directorio aparece el enlace a los scripts de /etc/init.d y unos llevan una S delante y otros una K indicando si se debe iniciar (Start) ese servicio o detener (Kill) El número que lleva asociado cada enlace es sólo el orden en el que se ejecutarán. Así pues, podemos configurar los servicios que arrancan en cada nivel de ejecución cambiando la K de delante por la S o viceversa. Podemos comprobar el nivel de ejecución en el que estamos trabajando mediante el comando runlevel:

Actualmente estamos en el nivel de ejecución 5 con entorno gráfico pero podríamos cambiar de nivel de ejecución en cualquier momento mediante el comando init seguido del nivel de ejecución. Por ejemplo para iniciar el nivel de ejecución 3: init 3 Veremos cómo desaparece el entorno gráfico y ahora si comprobamos el nivel de ejecución en el que estamos: runlevel

Nos indica que hemos pasado del 5 al 3. Si volvemos al nivel de ejecución 5: init 5

Puede resultar bastante tedioso el configurar qué servicios se ejecutan en cada nivel de ejecución de la forma que acabamos de ver. Para facilitar la tarea, existen herramientas tanto gráficas como de línea de comandos para tal efecto. Con chkconfig podemos configurar qué servicios se inician al arrancar el sistema y cuáles no. Lo único que hace esta herramienta es modificar los scripts que acabamos de ver pero de una forma que resulta mucho más amigable de cara al usuario. Con el comando chkconfig --list listamos los servicios que están actualmente configurados en el sistema:

Como se aprecia en la imagen, los servicios pueden ser configurados en cada nivel de ejecución. Por ejemplo, el servicio "anacronr" se iniciará en los niveles de ejecución 2, 3, 4 y 5 y permanecerá deshabilitado en el resto de niveles. Podemos configurar esto mediante chkconfig, por ejemplo, podemos decirle que inicie anacron también en el nivel de ejecución 1: chkconfig --level 1 anacron on Ahora si miramos la configuración: chkconfig --list | grep anacron

Por defecto, si utilizamos chkconfig para poner a on u off un determinado servicio sin especificar el nivel de ejecución que utilizará, toma por defecto los niveles de ejecución 2, 3, 4 y 5: chkconfig anacron off

chkconfig anacron on

Como siempre, para más opciones consultar man chkconfig Además de por línea de comandos, casi todas las distribuciones incluyen herramientas gráficas para poder gestionar los servicios. En Centos por ejemplo, si escribimos system-config-services sacaremos la siguiente interfaz gráfica: Gestión de procesos 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root: su – 2. Muestra de forma dinámica el uso de los recursos que están teniendo los procesos. Mostramos la información del uso de recursos mediante el comando top: top

3. Modifica la información que muestra top añadiendo las columnas del UID y el PPID. Vamos a modificar las columnas que muestra top, lo primero accedemos a el: top Pulsamos la tecla "f" para modificar las columnas que muestra el comando.

Ahora pulsamos la tecla "b" para habilitar la columna PPID y la "d" para habilitar la columna UID.

Ahora si pulsamos "esc" para volver a la pantalla anterior veremos que se nos muestra estas dos columnas.

4. Haz que el comando top vuelque 3 iteraciones en un fichero llamado uso_sistema.txt. Visualiza el contenido de dicho fichero. Volcamos 3 iteraciones del comando top en un fichero llamado uso_sistema.txt, para ello debemos convertir a top al modo batch para que pueda ser volcado en un fichero: top -bn 3 > uso_sistema.txt Si mostramos el contenido del fichero veremos la información de las 3 iteraciones. Esta función es muy util. 5. Haz que el comando top ordene los procesos según su uso de memoria. Para ordenar top según el uso de memoria de los procesos: top M

6. Lanza visudo en segundo plano. Lanzamos visudo en 2º plano: visudo &

7. Devuelve al primer plano a visudo y sal de el. Traemos al primer plano el proceso recién lanzado: fg 1 8. Muestra todos los procesos lanzados por el usuario root. Mostramos todos los procesos lanzados por el usuario root cuyo uid es 0: ps -u 0

9. Muestra los procesos en un formato orientado al usuario. Mostramos los procesos en formato orientado al usuario: ps u

10. Muestra los procesos en forma de árbol con el PID de cada proceso. Mostramos los procesos en forma de árbol junto con su PID: pstree –p

11. Muestra los argumentos pasados a cada proceso con pstree. Mostramos los parámetros pasados a los procesos: pstree –a

12. Muestra las señales que se le pueden mandar a un proceso.

Mostramos las señales que se les pueden pasar a los procesos: kill -l

13. Lanza el proceso xeyes en 2º plano desde la terminal de la máquina virtual. Lanzamos el proceso xeyes en 2º plano:

14. Mándale una señal al proceso xeyes para que se detenga. Le mandamos una señal al proceso xeyes para que se detenga, concretamente debemos mandarle la señal 19 (SIGSTOP): kill -s 19 5981

Comprobaremos que los ojos se han quedado parados y no responden al movimiento del ratón. 15. Mándale una señal al proceso xeyes para que continúe. Ahora le vamos a pasar la señal 18 (SIGCONT) para que continúe ejecutándose el proceso xeyes. kill -s 18 5981 Comprobaremos que los ojos vuelven a responder al movimiento del ratón. 16. Mata el proceso xeyes. Matamos el proceso xeyes: kill 5981 No hace falta especificar la señal 9 puesto que es la señal por defecto.

17. Vuelve a lanzar el proceso xeyes en 2º plano, crea una terminal virtual y lanza ahí también el proceso xeyes en 2º plano. Vuelve a la terminal principal. Lanzamos el proceso xeyes en 2º plano: xeyes &

Creamos una terminal virtual: screen Lanzamos el proceso xeyes en 2º plano: xeyes &

Volvemos a la terminal principal pulsando control+a+d

18. Con un solo mandato haz que ambos procesos se detengan y se muestre un mensaje como que la señal se mandó correctamente. Hacemos que los dos procesos se detengan y se nos informe sobre si la señal se ha mandado correctamente o no: killall -s 19 xeyes –v

Ambos procesos han sido detenidos correctamente. 19. Mata los dos procesos xeyes con una sola orden. Matamos ambos procesos: killall -s 9 xeyes

Aquí sí que hace falta especificar el número de señal. 20. Lanza el proceso xeyes con prioridad 5 en segundo plano. Lanzamos el proceso xeyes con prioridad 5: nice -n 5 xeyes &

21. Loguea con la cuenta fernando y asígnale una prioridad de -5 al proceso xeyes. ¿Te deja? ¿Por qué? Logueamos con la cuenta de fernando. ssh fernando@127.0.0.1 Asignamos la prioridad -5 al proceso que acabamos de lanzar: renice -5 3596

No nos permite cambiarle la prioridad a -5 ya que sólo root puede asignar prioridades menores de 0. 22. Loguea con la cuenta de root y cámbiale la prioridad al proceso xeyes a -5 Volvemos a usar la cuenta de root: su – Le asignamos la prioridad -5 al proceso: renice -5 3596

23. Comprueba los procesos que tienen abierto el directorio /usr/sbin Lo comprobamos mediante:

lsof +d /usr/sbin

24. Lista los ficheros abiertos por root. Listamos los ficheros abierto por el usuario root: lsof -u root

25. Lanza una terminal virtual y ejecuta "yum update" ahí. Vuelve a la terminal original y crea una segunda terminal virtual. Vuelve a la terminal original. Creamos una terminal virtual: screen Ejecutamos yum update: yum update -y Salimos de la terminal virtual presionando control+a+d y creamos una nueva: screen Volvemos a salir de la terminal virtual mediante control+a+d. 26. Comprueba cuántos terminales virtuales están en ejecución. Ahora listamos las terminales virtuales existentes: screen -list

Comprobamos que hay dos. 27. Conéctate a la primera terminal virtual y comprueba si ha acabado el proceso de actualización. Nos conectamos a la primera terminal para comprobar si ya ha acabado el proceso de actualización: screen -x 3928.pts-4.80 Comprobamos que efectivamente ha acabado el proceso de actualización. 1. Conéctate a tu máquina virtual Centos y utiliza la cuenta de root Accedemos a la máquina vía putty o bien a través de la propia terminal que lleva incorporada y usamos la cuenta de root: su – 2. Comprueba qué puerto utiliza el servicio ssh. Comprobamos el puerto utilizado por el servicio ssh: cat /etc/services | grep ssh

3. Comprueba si está corriendo el servicio ssh. Comprobamos el servicio ssh: /etc/init.d/sshd status o service sshd status

4. Detén el servicio ssh. Paramos el servicio: /etc/init.d/sshd stop o service sshd stop

5. Utilizando putty, intenta conectarte a tu máquina virtual Centos. Probamos a conectarnos vía putty: Al intentar conectarnos a la IP de nuestra máquina al puerto 22, nos aparecerá lo siguiente:

6. Inicia el servicio ssh. Volvemos a iniciar el servicio ssh para poder conectarnos vía putty: /etc/init.d/sshd start o service sshd start

Normalmente es una buena práctica cambiar el puerto por defecto para las conexiones ssh por motivos de seguridad. Podemos modificar el puerto cambiándolo en el fichero /etc/ssh/sshd_config descomentando la línea #Port 22 y poniendo ahí el que queramos. 7. Lista los scripts de manejo de servicios. Listamos los scrips de manejo de servicios: ls /etc/init.d

8. Obtén la lista de todos los servicios configurados en la máquina junto a los niveles de ejecución en los que se inician. Para sacar esa lista usaremos chkconfig: chkconfig –list

9. Cambia la configuración del servicio ssh para que se inicie en el nivel de ejecución 1. Compruébalo. Hacemos que el servicio ssh se inicie en el nivel de ejecucicón 1: chkconfig sshd on --level 1 Comprobamos que se ha realizado el cambio: chkconfig --list | grep sshd

10. Cambia al nivel de ejecución 1 y comprueba que el servicio ssh está corriendo. Cambiamos al nivel de ejecución 1: init 1 Comprobamos si el servicio sshd está iniciado: /etc/init.d/sshd status o service sshd status

11. Vuelve al nivel de ejecución 5. Volvemos al nivel de ejecución 5: init 5 12. Conéctate a la máquina virtual vía putty y comprueba si hay alguna conexión establecida con el servicio ssh. Nos conectamos vía putty a la ip de la máquina al puerto 22. Una vez dentro, comprobamos si hay alguna conexión abierta al servicio sshd: netstat -a | grep ssh

Aparece la conexión que acabamos de abrir vía putty. 13. Muestra los servicios que estén escuchando en algún puerto junto con su PID. Mostramos los servicios que están escuchando en algún puerto junto a su PID: netstat –lp

14. Mediante la interfaz gráfica, muestra los servicios en el nivel de ejecución 3, 4 y 5. Abrimos la interfaz gráfica escribiendo: system-config-services Mostramos los niveles de ejecución 3, 4 y 5 yendo a "Editar nivel" "Nivel de ejecución todos"

15. Deshabilita el servicio autofs en los tres niveles de ejecución. Deshabilitamos en servicio autofs en los tres niveles de ejecución anteriores: Desmarcamos las tres casillas para el servicio.

Gestores de arranque Los pasos que realiza el sistema Linux a la hora de arrancar, lo que se conoce como secuencia de arranque: 1. Al pulsar el botón de encendido lo primero que ocurre es que se inicia la BIOS. La BIOS hace un test al equipo y comprueba que todos los componentes funcionen correctamente. Después, la BIOS accede a una memoria no volátil (nvram) que guarda la información de qué dispositivo se va a utilizar para el arranque del sistema (normalmente suele ser un disco duro). Una vez localizado el dispositivo de arranque se acceder a el y se lanza el cargador de arranque o bootloader. 2. El bootloader se encuentra en el primer sector del dispositivo utilizado para el arranque al cual se le conoce como MBR (Master Boot Record). El MBR tiene un espacio muy reducido (512 bytes) el cual contiene una pequeña parte del bootloader y la tabla de particiones. Al tener esta limitación de espacio, se hace que el bootloader cargue el resto de la información desde otra partición más grande. La función principal el bootloader es cargar el kernel y ejecutarlo. 3. Cuando el kernel se inicializa, inicia los dispositivos con sus respectivos drivers, monta el sistema de archivos de root / en modo sólo lectura y, finalmente, inicia el proceso padre /sbin/init (PID 1) al cual le pasa los mismos parámetros que ha recibido el. 4. Una vez iniciado el init, este lee la configuración del fichero /etc/inittab e inicia los scripts contenidos en /etc/rc.d/ en el nivel de ejecución definido en el /etc/inittab. Después inicia las consolas virtuales y finalmente, inicia la ventana X (entorno gráfico) si el sistema se ha iniciado en el nivel de ejecución 5. Conocer el funcionamiento del arranque del sistema es básico a la hora de resolver ciertos problemas. Si comprobamos que nuestro sistema no arranca deberemos acceder en modo monousuario para comprobar que el bootloader esté funcionando correctamente y que tanto el /etc/inittab como los scripts que este ejecuta estén correctos. En el caso de que no podamos acceder al sistema en modo monousuario podemos probar con lo que se llama un "Live CD" . Un Live CD, también conocido como Live

Distro es un sistema operativo contenido en un medio extraíble que puede ejecutarse sin necesidad de instalarlo en el disco duro y que utiliza la memoria RAM el equipo como disco duro virtual y el medio extraíble como sistema de archivos. Por lo tanto podremos utilizarlo para poder comprobar los problemas que hayan surgido durante el arranque del sistema en caso de que no podamos acceder en modo monousuario. Así pues, un gestor de arranque o bootloader es un programa que administra el proceso de arranque del sistema y le añade funciones al mismo. Es posible que tengamos configurados en nuestro equipo dos sistemas operativos diferentes como son Linux y Windows, en tal caso, el gestor de arranque nos permitiría elegir qué sistema operativo deseamos iniciar. En los sistemas operativos Linux, normalmente el gestor de arranque es o GRUB o LILO siendo el primero el más utilizado por la mayoría de las distribuciones Linux desde hace ya unos años. Una de las diferencias entre los dos sistemas es que Grub lee su archivo de configuración desde el disco duro cada vez que arranca el sistema para evitar que el usuario escriba en el MBR. En cambio en Lilo, cada vez que se hace un cambio en el archivo de configuración, este escribe los cambios en el MBR y si esta operación no se realiza correctamente, es posible que el sistema no pueda iniciarse. Lilo tampoco tiene una interfaz de comando interactiva a diferencia de Grub y no puede leer las particiones ext2. A todo esto le añadimos que Grub es actualizado con mucha frecuencia y que ha sido adoptado como el cargador de arranque por defecto de la mayoría de las distribuciones Linux lo cual está haciendo que Lilo cada vez sea menos usado. Gestor de arranque LILO LILO (Linux Loader) fue desarrollado en un primer momento por Werner Almesberger y ahora se encuentra a cargo de John Coffman. Lilo permite arrancar hasta 16 sistemas operativos desde un equipo. El fichero de configuración de Lilo es /etc/lilo.conf el cual, si no existe deberá ser creado. Cada vez que hagamos cambios en este fichero deberemos ejecutar el comando lilo, de lo contrario el gestor no se enterará de los cambios introducidos y por lo tanto será incapaz de realizarlos. Algunas de las opciones que se le pueden pasar son las siguientes: boot= Aquí es donde se define la partición en la que se va a instalar Lilo. Puede ser el sector de arranque de un disquete (/dev/fd0), el sector de arranque de una partición raíz de linux (/dev/hda1 con discos IDE o /dev/sda1 con discos SCSI) o se puede instalar en el MBR (/dev/hda para discos IDE o /dev/sda para discos SCSI) message= Imprime el archivo seleccionado al cargar lilo. map= Fichero en el cual estará el mapa de Lilo. El mapa es un fichero generado por Lilo que contiene punteros a cada uno de los sectores de arranque del sistema operativo. Si se omite, se tomará /boot/map por defecto. timeout= Tiempo en décimas de segundo que esperará Lilo a que el usuario pulse una tecla antes de arrancar el sistema operativo por defecto. prompt Muestra boot: en el arranque del sistema permitiendo que se le puedan pasar comandos. Si se omite habrá que pulsar Ctrl, shift o alt para poder sacar esta función.

default= Arrancará el sistema seleccionado por defecto. image= Donde se encuentra la imagen del kernel que queremos arrancar. label= Etiqueta que le queremos asignar al sistema operativo en cuestión. password= Aquí asignaremos la clave de acceso. initrd= Aquí se define el fichero que se usará como el disco RAM inicial para cargar los módulos del kernel. other= Aquí especificaremos las imágenes de otros sistemas operativos distintos de Linux. Si simplemente vamos a tener un S.O en el equipo, lo habitual es instalar Lilo en la partición raíz, en cambio si vamos a tener más de un S.O y deseamos que Lilo gestione el arranque deberemos optar por instalarlo en el MBR. Vamos a instalar LILO en nuestra máquina virtual Ubuntu. Una vez instalado le pasaremos los parámetros de configuración siguientes en el fichero de configuración /etc/lilo.conf: Lilo se instalará en /boot/sda, es decir,en el MBR aunque no tengamos más sistemas operativos en el equipo. El sistema de ficheros estará en /boot/sda2 Deberá aparecer la línea boot: durante el arranque. La imagen del kernel a usar es /boot/vmlinuz-2.6.35-22-generic Como etiqueta le asignaremos "Ubuntu Curso" Como initrd le asignaremos /boot/initrd.img-2.6.35-22-generic Lo configuraremos en modo sólo lectura. Podemos instalar lilo en la máquina virtual ubuntu con el comando aptitude install lilo. Una vez instalado creamos el fichero /etc/lilo.conf y añadimos el siguiente contenido:

Podemos conocer cómo están configuradas las particiones en nuestro equipo mediante el comando fdisk -l:

Una vez modificado el fichero de configuración, debemos ejecutar el comando lilo como root. El comando lilo comprobará el contenido del fichero /etc/lilo.conf y creará el mapa personalizado con los punteros a los sectores de arranque. Si hay algún problema a la hora de ejecutar lilo nos avisará para que lo corrijamos. Es importante solucionar los problemas que surjan debido a que si no los dejamos resueltos es posible que el sistema no arranque.

En nuestro caso símplemente arroja dos warnings que no tienen importancia y por lo tanto no requieren de nuestra intervención. Ahora si reiniciamos el sistema mediante reboot nos aparecerá la siguiente pantalla:

Podremos elegir el sistema a arrancar mediante las flechas de dirección, escribiendo su nombre y pulsando "enter" o escribiendo su letra asignada, en este caso la "U". En nuestro caso sólo tenemos un sistema a arrancar, escribimos el nombre del sistema y le damos a enter con lo que arrancará:

Es importante además, aplicar medidas de seguridad a la hora de trabajar con los gestores de arranque. Si no protegemos el acceso a las particiones del sistema, cualquiera que reinicie el equipo y tenga acceso a la línea de comandos podría entrar en modo monousuario escribiendo "linux single":

Una vez en modo monousuario, tendría acceso a ficheros confidenciales e incluso podría modificar la contraseña de root. Por ello debemos proteger el acceso mediante una contraseña que especificaremos también en el fichero de configuración de Lilo /etc/lilo.conf Además de proteger el gestor mediante una contraseña deberemos cambiarle los permisos también al fichero de configuración /etc/lilo.conf con el fin de que sólo pueda leerlo root. Vamos a establecer una contraseña para restringir el acceso a la línea de comandos de Lilo. También vamos a cambiarle los permisos al fichero /etc/lilo.conf para que no todo el mundo pueda leerlo. Comprobamos que el fichero /etc/lilo.conf puede leerlo cualquiera:

ls -l /etc/lilo.conf

Modificamos los permisos de dicho fichero para que sólo root pueda leer y escribir: chmod 600 /etc/lilo.conf ls -l /etc/lilo.conf

Ahora vamos a establecer una contraseña para lilo, accedemos al fichero de configuración y le asignamos el parámetro password: joe /etc/lilo.conf Dejamos el fichero así:

Ahora ejecutamos el comando lilo como root para hacer los cambios efectivos: lilo

Ahora vamos a reiniciar la máquina para comprobar los cambios que hemos realizado: reboot Ahora cuando escribamos cualquier cosa en la línea de comandos nos pedirá la contraseña que acabamos de establecer:

Gestor de arranque GRUB GRUB (Grand Unified Bootloader) fue desarrollado en un primer momento por el programador Erich Stefan Boleyn como parte del trabajo en el arranque del sistema operativo GNU/Hurd, realizado por la Free Software Foundation.

Se puede utilizar en una gran cantidad de sistemas operativos y es el gestor de arranque por defecto de la mayoría de las distribuciones linux. Grub soporta los siguientes tipos de sistemas de ficheros: ext2/ext3/ext4 XFS ReiserFS UFS FAT16/FAT32 NTFS JFS HFS Entre las principales características de Grub se encuentran las siguientes: Buena gestión de la memoria. Multiplataforma. Muy portable. Interfaz gráfica muy potente. El fichero de configuración de Grub es /boot/grub/menu.lst en Centos, en el y, al igual que pasaba con Lilo, se le pueden especificar diversos parámetros, entre los que nombramos algunos: title A continuación de esta sentencia especificaremos el nombre que le vamos a poner al S.O. Cuando el sistema arranque y aparezca grub, este será el nombre que veamos. Normalmente debajo de cada sentencia title, aparecen los parámetros root, kernel, initrd… root Indica el disco duro y la partición en la que se encuentra el S.O. Por ejemplo, root (hd0,0) indica que el S.O se encuentra en el disco 0, en la partición 0. root (hd2,1) indica que el S.O se encuentra en el segundo disco en la partición 1. kernel Indica dónde se encuentra la imagen del sistema operativo. initrd Aquí se define el fichero que se usará como el disco RAM inicial para cargar los módulos del kernel. default Sistema operativo que se iniciará por defecto cuando se acabe el tiempo definido en la variable timeout. Si le especificamos un 0, iniciará el sistema operativo que esté más arriba en el fichero de configuración, con un 1 el segundo y así sucesivamente… timeout Tiempo que esperará el gestor de arranque a que hagamos una selección antes de iniciar el S.O por defecto. splashimage Aquí es donde definiremos la imagen que se utilizará como fondo en Grub. Tiene que tener unas medidas específicas y estar en un formato dado o sino no funcionará. Concretamente, la imagen no puede tener más de 14 colores, debe ser tener una resolución de 640x480 y debe estar en formato .xpm. password Podremos definir la contraseña para restringir el acceso al gestor de arranque y por lo tanto hacer que no puedan acceder en modo monousuario. Para poder introducir contraseñas encriptadas en el fichero de configuración, grub incorpora una herramienta llamada grub-md5-crypt que convierte la contraseña que se le pase por línea de comandos en una contraseña codificada en md5 haciendo que sea más segura.

Si vamos a utilizar esta contraseña deberemos poner --md5 después del parámetro password para que grub lo entienda. Si comprobamos el fichero /boot/grub/menu.lst de nuestra máquina virtual Centos veremos que el fichero de configuración está así:

El S.O por defecto para arrancar es CentOS aunque ahora mismo no hay ninguno más configurado. Esperará 5 segundos antes de arrancar el sistema por defecto. La opción hiddenmenu esconde las particiones cuando iniciamos el sistema de manera que para poder verlas y cambiarlas deberemos presionar una tecla para que aparezca. El S.O se encuentra en (hd0,0). Es importante entender que Grub trata los nombres de las particiones de manera diferente a como lo hace el sistema operativo, si hacemos un fdisk -l veremos:

En el sistema, la letra "a" de sda representa el primer disco y el número indica el número de la partición, por lo tanto sda1 es la primera partición del primer disco, si tuviéramos sdc2, se referiría a la segunda partición del tercer disco y así sucesivamente… Para Grub, sda1 sería (hd0,0), sda2 sería (hd0,1) y así sucesivamente. Si tuviéramos las particiones sdc1 y sdc2 por ejemplo, grub las interpretaría como (hd2,0) y (hd2,1) respectivamente. Así pues, debemos hacer un trabajo de adaptar los nombres de las particiones al formato de Grub. La opción rhgb es un modo gráfico especial de los sistemas Red Hat y la opción quiet hace que no se muestren los errores que aparezcan durante el arranque por pantalla. Además de lo nombrado anteriormente, es importante al igual que pasaba con Lilo, proteger la edición de las particiones en el gestor al arrancar el sistema mediante una contraseña para evitar que estas sean manipuladas por cualquier usuario y por lo tanto puedan acceder al sistema en modo monousuario con el riesgo que ello conlleva.

Para acceder en modo monousuario, durante los 5 segundos que da grub para arrancar el sistema por defecto pulsaremos cualquier tecla y estaremos en la siguiente pantalla:

Ahora si pulsamos la tecla "e" entraremos en la edición de la configuración de grub para la partición sobre la que estemos:

Si nos vamos a la línea del kernel que usa ese sistema operativo y la editamos añadiendo un "1" al final, iniciaremos en ese nivel de ejecución, es decir, en modo monousuario. Presionamos la "e" sobre la línea de kernel y lo añadimos:

Una vez hecho el cambio, pulsaremos "enter" para guardar el cambio y después la tecla "b" para que arranque con esa configuración. Una vez hecho esto el sistema arrancará en modo monousuario y tendremos acceso a cualquier recurso del sistema:

Esta tarea es de extrema utilidad cuando no conseguimos hacer que el sistema arranque. Entraremos en este modo e intentaremos reparar los archivos para que vuelva a iniciarse en modo normal. Si el sistema se encuentra inaccesible incluso en modo monousuario deberemos pensar en intentarlo con un Live Cd. Debido al gran riesgo que implica que otro usuario acceda al sistema en modo monousuario, vamos a proteger la edición de las particiones en grub mediante una contraseña. Para ello utilizaremos una contraseña encriptada mediante la herramienta grub-md5-crypt y la añadiremos al fichero principal de configuración de Grub. Así pues, utilizamos la herramienta que incorpora Grub (grub-md5-crypt) para encriptar una contraseña que nosotros le vamos a pasar por la línea de comandos: grub-md5-crypt Nos pedirá la contraseña a encriptar:

Escribimos "12345" por ejemplo y nos devolverá la contraseña encriptada:

Ahora debemos copiar la contraseña que nos ha devuelto grub e irnos al fichero de configuración de este: joe /boot/grub/menu.lst Añadimos la línea con la contraseña encriptada con lo que el fichero de configuración quedará así:

También podríamos poner la contraseña en claro pero es más seguro así y no hace falta que modifiquemos los permisos del fichero. Es importante decir que en el lugar donde hemos puesto la contraseña, afectaría a todos los S.O que estuviera configurado en el fichero. Si sólo quisiéramos asignarle esa contraseña a un S.O en concreto colocaríamos la orden justo debajo del title que le hubiéramos asignado al S.O Una vez hechos los cambios y guardados, reiniciamos la máquina virtual mediante reboot. Ahora cuando aparezca esta pantalla:

Veremos que en la parte de abajo ya no nombra las opciones de editar entre otras y únicamente nos deja iniciar el S.O tal y como está y presionar la tecla "p" para introducir la contraseña que nos permita editar las opciones. Si presionamos p:

Introducimos la contraseña y una vez comprobado que es la correcta, nos aparecerá la misma ventana pero ahora ya nos dejará editar:

PROGRAMAR TAREAS Y ADMIINIISTRAR BACKUPS El cron es un sistema para programar procesos que van a ser ejecutados con regularidad. Uso común de cron son para empezar un backup, para rotar archivos de registro y inicializar script del sistema. El sistema cron consiste de un daemon y un archivo de configuraciones por usuarios. Cada archivo de configuración es denominado una tabla cron o mejor dicho crontab. Una entrada en un archivo crontab se llama un evento o trabajo. Existen por lo menos dos versiones utilizadas en los sistemas GNU/Linux. Mientras que los conceptos básicos son lo mismo, algunos particulares varían. Siempre revise su documentación y que entienda como utilizar cualquier herramienta de administración de sistema. Los siguientes tópicos se discuten en esta sección:

• El daemon de cron • Los archivos crontab

El Daemon cron Como la mayoría de los servicios del sistema la funcionabilidad de cron es proveída por un sistema daemon cron o crond dependiendo de la distribución que usted utiliza. El Cron lee el archivo de configuración para determinar cuales comandos ejecutar cuando. Cada un minuto cron lee todos los archivos crontab para ver que comando debe ejecutar. Si el encuentra una entrada que considera con la hora actual; el ejecuta el comando correspondiente, ejecutándolo con el UID del dueño del archivo crontab. Por esto solo podrás ejecutar a través del cron lo mismo que tus permisos te permiten. Cron puede ser configurado para permitir o denegar a usuarios específicos la habilidad para programar eventos. Los archivos para especificar quien puede utilizar cron son /etc/cron.allow y /etc/cron.deny. Si el archivo cron.allow existe, solo los usuarios listados en el pueden utilizar cron si el archivo no existe solo usuarios que no aparecen en el archivo cron.deny. Un archivo cron.deny vacío significa que todo los usuarios pueden utilizar cron. Si los archivos no existen el programa puede permitir o a todos los usuarios o solo a root dependiente de la configuración y la distribución en uso. El cron mantiene un directorio en spool para almacenar los archivos crontab. Casi siempre este directorio se encuentra en /var/spool/cron y contiene un archivo crontab para cada usuario que tiene un trabajo programado. También existe un archivo crontab del sistema en /etc/crontab el crontab usa una sintaxis un poco diferente del de los usuarios, con un campo agregado que especifica bajo el cual el trabajo del usuario ha de ser ejecutado. Normalmente la salida del trabajo ejecutado por cron es enviado por correo al usuario. Esto puede ser cambiando y redireccionar la salida del archivo o especificar un usuario diferente para enviar el correo. Los Archivos crontab El archivo crontab le dice al daemon cron que programas usted quiere empezar y cuando empezarlo. Cada usuario tiene un archivo crontab y también existe un archivo crontab en el directorio /etc. El programa utilizado para administrar los archivos crontab también se llama crontab. Existen dos tipos de entrada: definición de variables de ambientes y eventos. Una definición de variable de ambiente se dice a cron colocar una variable para que un programa que el ejecuta debido a un evento del cron. Para asignar esta variable, entre el nombre de la variable con un símbolo de “=” y el valor de

la variable. Hay una variable de ambiente especial denominada MAILTO que especifica donde se debe de enviar la salida. Si lo deja en blanco (MAILTO =””) toda la salida es ignorada. Por defecto la salida es enviada correo al dueño del archivo crontab. La mejor parte de las entradas en el archivo crontab son eventos, un evento tiene dos partes: el tiempo que el evento se ejecuta y que hacer cuando llegue el momento de ejecutarlo. Cinco campos en la entrada del evento representan tiempos. En este orden, ellas son: minuto, hora, día del mes, mes, día de la semana. Los campos son separados por espacios o tab. Recuerde que las horas se representas en horas militar de 24 horas. En el campo del día de la semana puede utilizar o cero o siete para domingo y los otros días en orden numérico. Un evento se ejecuta cuando el tiempo del campo coincide con el tiempo actual. El cron revisa una vez por minuto para encontrar entradas que deben ser iniciada, para un evento, ser iniciado cada campo de tiempo debe coincidir con el tiempo actual excepto el día de la semana y el día del mes; solo uno de estos dos campos necesita coincidir. Además de escribir un valor simple en cada campo puedes utilizar un comodín, un rango de valores, una lista de valores o un incremento, el “*” es el carácter del comodín que coincide con cualquier valor. Un rango se delimita por un símbolo “-“indicando que cualquier valor entre estos valores es correcto. Una lista es separada por comas. Un incremento es indicado utilizando el carácter “*” seguido por (/), seguida por un numero (*/2). El campo de incrementar cuando el valor es un múltiple del número después de la barra. Después de los 5 campos se encuentra el comando a ser ejecutado el comando toma el resto de la línea después de los campos del tiempo y puede incluir espacio. La mayoría de las versiones de cron requiere un campo adicional del nombre del usuario antes del campo del comando para el crontab del sistema, /etc/crontab. Este es el usuario bajo el cual el comando se ejecutara, casi siempre este usuario será root o deny o nobody. Los siguiente es un ejemplo del archivo crontab.

Tenga especial cuidado de que todos los campos de tiempo estén correctos. Ya que no recibirás ningún mensaje de error si cometes cualquier falta al digitar sus entradas, pero su trabajo no ejecutara como espera. Comandos del crontab Usted no debe editar sus archivos crontab directamente en el directorio /var/spool/cron. Debe utilizar siempre el comando: # crontab -e Este comando utilizara el editor por defecto definido en las variables de ambiente VISUAL o EDITOR.

Si ningunas están definidas utilizara el vi cual es el editor por defecto de las mayorías de distros de Linux. Puedes desplegar sus crontab actual con el siguiente comando: $ crontab -l Para remover todo el contenido de su crontab, utilice el comando: $ crontab -r Puedes especificar a crontab que lea las tablas desde un archivo: $ crontab /home/usuario/mi_crontab Cuídese de no confundir el mecanismo que cron utiliza para determinar cual archivo crontab debe utilizar, así que utilice la opción –u para especificar de cual usuario es el archivo crontab que se va a afectar: $ crontab -u ivellise /home/ivellise/su_crontab Trabajos Preconfigurados del cron La mayoría de las distribuciones vienen preconfiguradas con varios trabajos cron activo. Éstos se proporcionan para ejecutar mayormente trabajos de la limpieza del sistema. Generalmente, ejecutan llamadas a scripts de nombre /etc/cron.weekly, /etc/cron.daily, /etc/cron.hourly y /etc/cron.mensual. El administrador del sistema entonces puede modificar estos scripts para hacer cualquier trabajo que el desee hacer regularmente. A excepción de los scripts programado a correr cada hora, estos scripts se fijan para ejecutarse tarde en la noche en horas de menos volumen de trabajo. Cada vez más, las distribuciones cambian hacia un sistema donde estos archivos shell scripts se substituyen por directorios de los shell scripts. El directorio tiene el mismo nombre que el shell script, pero en vez de funcionar un solo script todo los shell scripts dentro del directorio son ejecutados. Esto es similar al sistema usado para iniciar y detener servicios al cambiar de runlevels. Se utilizan los trabajos típicos del cron para poner al día bases de datos del sistema. Un trabajo común del cron llama el comando logrotate. Este hace un backup de los archivos del registro (logs) y los recorta de modo que no sean demasiado grandes. Otro comando que normalmente se ejecuta a diario es el comando updatedb. Este comando crea una lista de todos los archivos en el sistema para poder utilizar el comando locate de localizar y encontrar archivos sin tener que buscar el sistema de archivos entero. Otros trabajos communes del cron son los de funcionar chequeos de seguridad en el sistema. At y batch El comando at se utiliza para ejecutar un comando o un script en un tiempo especificado. Diferente a cron, estos trabajos funcionan solamente una vez, no sobre una base que se repite. El comando batch es como el comando at, pero él específica que los comandos se ejecuten cuando el promedio de la carga este por debajo de cierto nivel. El límite medio de la carga por defecto es 0.8, pero un cualquier límite puede ser especificado por el superuser. Los trabajos sometidos vía y los comandos at y batch son manejados por el daemon atd. Este programa trabaja como el daemon del cron pero mantiene una cola de los trabajos y de los tiempos que se suponen ser ejecutados. El daemon atd no necesita

comprobar para saber si hay trabajos nuevos; solo esperas hasta que es hora de comenzar un trabajo ya en cola o en el comando at le dice que agregue algo a la cola. El sistema at tiene la estructura de archivo permitir y denegar (/etc/at.deny (/etc/at.allow) y el control de quien puede utilizarlo. Los campos funcionan exactamente como los del sistema cron. El directorio spool para el atd está generalmente en el directorio/var/spool/at. La única opción probablemente del atd que usted necesitará utilizar es la opción -1, que especifica el promedio de la carga máxima en el cual los trabajos se permiten ejecutar. Para programar un trabajo en at, utilice el comando at y de el tiempo que usted desea comenzar el trabajo. Cuando usted presione ENTER, usted entrará un modo que le permitirá digitar los comandos que usted desea poner a funcionar en el trabajo. De entrada a los comandos y presione CONTROL+D para terminar la entrada:

Alternativamente, usted puede especificar un archivo para funcionar usando - la opción de f:

Observe el mensaje de alerta de utilizar /bin/sh. Esto puede ser significativo si usted usa el tcsh en vez del bash porque los dos tienen un sintaxis un poco diferente. Cualquier salida del comando se envía al usuario por e-mail. El comando at es bien flexible en aceptar formatos de fecha y hora. Usted puede especificar el tiempo en formato de hh:mm o simplemente la hora. También funciona la palabra clave now para especificar el tiempo actual. Usted puede especificar la fecha en formato de mm/dd/yy o de mm/dd o escribir el nombre del mes. Usted puede también especificar un tiempo seguido por un signo de más (+} con un incremento en un cierto número de minutos, de horas, de días, o de semanas. Los nombres de los días y las palabras claves today y tomorrow están también disponibles para especificar una fecha. La cosa principal a recordar es que el tiempo es requerido y debe estar en formato de 24 horas a menos que usted especifique a.m. o p.m. Los ejemplos siguientes son para ilustrar algunos de estos formatos: $ at now + 3 hour $ at 6:10pm + 1 days $ at 5:30 tomorrow $ at 2am $ at 8pm 12/23/2003 $ at 9:35 Jul 26 $ at 6 Saturday Usted puede echar un vistazo a la cola en una de las dos siguientes maneras:

[root@www /root]# at -l 1 2003-07-26 20:00 a root 2 2003-07-26 20:00 a root 3 2003-07-27 08:00 a root 5 2003-07-27 08:00 a root 6 2003-07-26 09:00 a root 7 2003-07-26 09:00 a root [root@www /root]# atq 1 2003-07-26 20:00 a root 2 2003-07-26 20:00 a root 3 2003-07-27 08:00 a root 5 2003-07-27 08:00 a root 6 2003-07-26 09:00 a root 7 2003-07-26 09:00 a root Ambos hacen la misma cosa, solo cambia la sintaxis del comando. Si usted es superusuario, usted verá los trabajos enumerados de todos los usuarios. La mayoría de las versiones de at no dejarán que usuarios normales listen los trabajos de otros usuarios. Para ver exactamente qué comandos en particular ejecutara un trabajo, uso at -c le dará una lista de todos los comandos que serán ejecutados. Puede demostrar muchas definiciones de variable de entorno y de cambio de directorio porque at ejecuta los trabajos en el mismo ambiente que fueron creados. Se utiliza el comando atrm para quitar/remover trabajos en cola. Solo liste el número del trabajo en la cola. Usted puede también utilizar la opción -d (o en algunas versiones -r) del comando: $ atrm 13 $ at -d BACKUP Y RESTAURAR Como regla general, necesitará hacer copia de respaldo de los directorios siguientes: /etc /home /root /var Si hace una copia de respaldo completa de estos directorios, habrá guardado no sólo sus configuraciones, sino también sus datos (en caso que se esté preguntando dónde están sus datos, están en el directorio /home/su_nombre_de_usuario/). Por favor, tenga presente que esto puede tomar un tiempo largo en completarse, pero es la apuesta más segura. Un esquema más sofisticado sería hacer copia de respaldo sólo de los archivos de configuración que han cambiado, dejando de lado los que no han cambiado. Esto llevaría más tiempo de “planificación”, pero llevará a tiempos de copia de respaldo más cortos (y también a tiempos de restauración más cortos) y a copias de respaldo que son “más fáciles” de portar de una máquina/versión de sistema operativo a otra. A continuación, se le presentará una lista de los archivos a los cuales debería prestarles la mayor atención. Note que estas listas no son exhaustivas en absoluto, en especial si ha hecho un montón de cambios en su sistema. En el directorio /etc: /etc/lilo.conf

Contiene la configuración del cargador de arranque LILO. Si, en vez de LILO, Usted usa grub, los archivos a incluir en la copia de respaldo son los que están en el directorio /boot/grub. /etc/fstab Contiene la configuración de las tablas de partición de los discos y los puntos de montaje asociados. /etc/modules.conf Contiene los módulos a cargar y sus parámetros de acuerdo al hardware de su sistema. Puede no ser de utilidad si se restaura en una máquina muy diferente, pero de todas formas puede proporcionar algunas pistas. /etc/isapnp.conf Contiene las configuraciones de ISAPnP si es que lo usa para configurar el hardware ISA plug’n’play. Nota: Con el núcleo 2.4.x puede no necesitar más este archivo, ya que el hardware plug’n’play se configura usando el sistema de archivos DevFS. /etc/X11/XF86Config-4 y/o /etc/X11/XF86Config Contiene las configuraciones de X. X es el “corazón” gráfico de GNU/Linux y todos los entornos de escritorio y administradores de ventanas del mismo. /etc/cups Contiene las configuraciones de CUPS. CUPS es el sistema de impresión predeterminado de Mandrake Linux. Si no utiliza CUPS y usa el sistema de impresión lpr, entonces tiene hacer copia de respaldo de /etc/printcap /etc/bashrc Configura al shell bash, para todo el sistema. /etc/profile Configura el entorno del sistema y algunos programas que se ejecutan al iniciar el sistema. /etc/crontab Configura los jobs de cron a ejecutar periódicamente, por ejemplo, para las tareas de mantenimiento del sistema. /etc/rc.d/* Configura los distintos niveles de ejecución del sistema. Usualmente, no necesitará hacer copia de respaldo de estos, excepto si agregó algún nivel de ejecución personalizado o cambio uno de los predeterminados. /etc/inittab Configura el nivel de ejecución predeterminado con el cual arranca su sistema. /etc/ssh Contiene las configuraciones de ssh. Si utiliza el acceso remoto seguro, es sumamente importante incluir este archivo. Si tiene un servidor web, un servidor FTP, u otros servidores, también haga una copia de respaldo de sus respectivos archivos de configuración. Note que no podemos listarlos a todos aquí ya que los mismos dependen del servidor que utilice. En el directorio /root y en el directorio personal de cada usuario /home/nombre_de_usuario, los directorios siguientes: ~/.gnome/* y ~/.gnome2/*

Configuraciones para el entorno de escritorio GNOME. ~/.kde/* Configuraciones para el entorno de escritorio KDE. ~/.mozilla/* Configuraciones para la familia de programas Mozilla. Los marcadores de Navigator, los filtros de correo de Messenger, etc. Note que este directorio también contiene todos sus mensajes de correo-e y de sus grupos de noticias. Definitivamente no quiere perder estos, ¿cierto? ~/Mail/* Si usa kmail este directorio contiene todos sus mensajes de correo-e. Definitivamente no quiere perder estos, ¿cierto? ~/.ssh/* Contiene las configuraciones personalizadas para el uso de ssh. Si utiliza a ssh, es obligatorio realizar copia de respaldo de este. Tampoco quisiera perder de vista a los archivos siguientes: ~/.bash_profile y ~/.bashrc Contiene las variables de entorno, los alias y más configuraciones para el shell bash. ~/.cshrc Contiene las variables de entorno, los alias y más configuraciones para el shell CSH. ~/.tcshrc Contiene las variables de entorno, los alias y más configuraciones para el shell tcsh. Ejemplo de Copia de Respaldo Usando tar Seguidamente, le presentaremos un pequeño script de copia de respaldo que usa a tar para hacer una copia de respaldo completa de su directorio personal. Necesitará permiso de lectura sobre los archivos y permiso de lectura y ejecución sobre los directorios que va a incluir en la copia de respaldo, de no ser así la operación de copia de respaldo fallará. #!/bin/bash # Crear una copia de respaldo comprimida de su directorio # personal en el archivo backup.tar.gz o backup.tar.bz2 # dependiendo del esquema de compresión usado. BACKUP_DIRS=$HOME # Quitar comentario de la línea siguiente si desea comprimir con GZIP #tar cvzf backup.tar.gz $BACKUP_DIRS # Aquí comprimimos con BZIP2... tar cvjf backup.tar.bz2 $BACKUP_DIRS Como puede ver este es un script de copia de respaldo muy simple que sólo hace una copia de respaldo de su directorio personal y pone el resultado en el mismo directorio. Vamos a mejorarlo un poquito. #!/bin/bash # Crear una copia de respaldo comprimida de todos los directorios # especificados y poner el archivo resultante en un directorio # de nuestra preferencia. BACKUP_DIRS=”$HOME /etc /etc/rc.d” BACKUP_FILENAME=`date „+%b%d%Y‟`

BACKUP_DEST_DIR=”/backups” # Quitar comentario de la línea siguiente para usar GZIP, dejarlo # para usar BZIP2 # tar cvzf $BACKUP_DEST_DIR/$BACKUP_FILENAME.tar.gz $BACKUP_DIRS # Aquí usamos BZIP2 para comprimir... # Comentar la línea siguiente para usar GZIP, quitar comentario # para usar BZIP2 tar cvjf $BACKUP_DEST_DIR/$BACKUP_FILENAME.tar.bz2 $BACKUP_DIRS Como puede ver en este último ejemplo, hemos añadido algunos directorios más a nuestra copia de respaldo y hemos usado un esquema de nombres para agregar la fecha de la copia de seguridad al nombre del archivo resultante. Por supuesto, puede mover el archivo tar.bz2 o tar.gz resultante a cualquier soporte que desee. Incluso puede hacer copia de respaldo directamente sobre el soporte que desea si lo monta y cambia la variable BACKUP_ DEST_DIR del script adecuadamente. Siéntase libre de mejorar este script y hacerlo tan flexible como desee. Restaurar La restauración de la copia de seguridad depende del programa, soporte y agenda que Usted utilizó para hacerlo. Aquí no cubriremos todos los casos de restauración, sino que sólo mencionaremos que Usted se tiene que asegurar de restaurar los archivos y/o directorios en los mismos lugares donde se encontraban cuando hizo la copia de respaldo para poder recuperar sus configuraciones y sus archivos de datos. Ejemplo de restaurar un Backup usando tar Ahora, veremos un pequeño script para restaurar la copia de respaldo que hicimos con tar usando el script que se presentó antes en “Ejemplo de copia de respaldo usando tar” Ejemplo: Necesita permisos de escritura sobre los archivos y directorios que va a restaurar, de no tenerlos, la operación de restauración fallará. #!/bin/bash # Extraer una copia de respaldo comprimida de todos los # Directorios especificados poniendo los archivos en sus lugares # Originales. BACKUP_SOURCE_DIR=”/backup” RESTORE_FILENAME=$1 # Quite el comentario de la línea siguiente si está comprimido # con GZIP #tar xvzf $BACKUP_SOURCE_DIR/$RESTORE_FILENAME # Restaurar una copia de respaldo comprimida con BZIP2... tar xvjf $BACKUP_SOURCE_DIR/$RESTORE_FILENAME Como puede ver, este script es bastante simple. Todo lo que tenemos que hacer es pasarle el nombre del archivo de la copia de respaldo que deseamos restaurar como parámetro (sólo el nombre del archivo, no la ruta completa), y el script restaura los archivos de la copia de respaldo en sus ubicaciones originales.

Archivos de Registros Comunes Los archivos de registro de Linux son idénticos de distro a distro, esto es causa de los factores de tradición y protocolo de UniX, POSIX (Portable Operating System Interface for UniX). Claro existen pequeñas diferencias pero no nada que no se puede aprender o inclusive enfrentar desde el primer día en la nueva distro. La siguiente lista es una lista que debe ser común a todas las distros de Linux: • /var/log/messages • /var/log/secure • dmesg • lastlog • Registros Dependientes de Procesos El Archivo /var/log/messages En el directorio /var/log, existe un archivo de nombre messages. Dentro de este archivo se encuentra una lista larga de los eventos (en orden cronológica), con cada entrada representando un registro individual. El archivo /var/log/messages es el archivo central del sistema de mensajes y registros del sistema. El almacena los mensajes de kernel con todos los programas que efectúan eventos que generan un registro. La mayor parte de los errores y mensajes del sistema se encuentran aquí en este archivo. Si no encuentras lo que buscas en el directorio /var/log/messages, o necesitas información mas especifica a cerca de un proceso en particular, busque archivos o subdirectorios con el nombre del programa en particular en el directorio /var/log. El Archivo /var/log/secure Otro de los archivos del registro de logs importante de GNU/Linux es el /var/log/secure (en otras distros no RedHat también puede estar con el nombre auth.log). El sistema en este archivo registra todos lo referente a usuarios que están accesando el sistema, como el usuario acceso y los posibles sucesos que pongan en peligro la seguridad del sistema. La mayor parte de esta información también esta disponible el archivo /var/log/messages. Por defecto todos los ingresos del root se registran en este archivo. Monitoreando estos archivos es una parte importantísima de la seguridad del sistema. El Comando dmesg Los mensajes del inicio del sistema del kernel son registrados en este archivo /var/log/dmesg. Este archivo contiene la información del subsistema del kernel y de las cargas de los modules en tiempo de encendido. A menudo, los drivers desplegan información de diagnostico de cada dispositivo y su modulo que el carga. Si un driver no se puede cargar por una mala configuración o problema del hardware, encontraras información en este archivo que Talvez te pueda orientar en tu búsqueda de fallas. Este archivo puede ser accesado directamente con un editor de texto o a través del comando dmesg. Comando lastlog Al invocar el comando lastlog, producirá una lista de los usuarios del sistema y la información de la ultima vez que ingresaron al sistema incluyendo de que maquina y a

través de que puerto y la fecha. Si el usuario nunca ingresado al sistema también hará referencia a esto. El comando lastlog recibe su información desde un archivo de nombre /var/log/lastlog. Este archivo no es de formato leíble por humanos. Registros Dependientes de Procesos Algunos programas tienen sus propios directorios y pueden almacenar una gran cantidad de información si son configurados correctamente con este objetivo. Daemons, así como httpd, squid y samba, comúnmente mantienen archivos y directorios separados detallando sus eventos específicos a las tareas que ellos desempeñan. Daemons de Registros GNU/Linux tiene varios métodos de archivar información en los archivos de registros. Algunos programas simplemente le escriben a sus propios archivo. La mayoría de los programas utilizan una Interfase de Programación de Aplicación (API) la cual es proveída por el kernel llamada syslog. Un daemon llamado syslogd acepta mensajes desde el kernel y decide donde almacenarlo. El kernel mismo tiene su propio mecanismo de registros. El daemon klogd acepta estos mensajes desde el kernel y se los envía al syslogd. En esta sección, cubriremos los siguientes temas: • Syslogd • Klogd El Estándar Syslogd En GNU/Linux, un estándar llamado syslog dicta como los programas envían mensajes a través del sistema. Las librerías del sistema que los programas utilizan contienen funciones syslog. Acceso a estas funciones le permite a programas producir los mensajes que pueden ser manejados por el sistema. Un daemon llamado syslogd escucha en el background por estos mensajes, les da formato y entonces los envía a los lugares pre-definidos en los archivos de configuración en /etc/syslog.conf. Configurar syslog Syslog se ejecuta por defecto en todas las distribuciones reconocidas de Linux. Sus valores de configuración por defecto deben servir sus necesidades. Por si acaso debes cambiarla o se desconfigura entonces, vamos a conoceré lagunas de sus características. Existen tres partes en una entrada típica del archivo Syslog con: • Facilidad • Prioridad • Acción La siguiente sintaxis es utilizada en el comportamiento de syslogd: mail .* - /var/log/mail Los primeros dos campos están a las izquierda. Ellos consisten en facilidad y prioridad, separadas por un punto. Ambas son palabras claves utilizadas internamente por el sistema de mensajería. En este ejemplo, la facilidad es correo (mail), con una prioridad siendo representada por un comodín, en este caso el asterisco (*). Este ejemplo

ejecuta lo siguiente, envía todos (*) los mensajes del sistema a la localidad (el correo, mail) /var/log/mail. El campo de Localidad es también conocido como acción. Además de estas tres partes del syslog.conf discutiremos ingresos remotos. Facilidad Las facilidades disponibles son: cron, daemon, kern, lpr, local, mail, news, priv, syslog, user, uucp Algunas de estas deben serle familiares ya que ellas reflejan procesos comunes del sistema. El proceso que deseas hacerles registros caerá en unas de estas categorías. El programa que crea el evento y necesita registrarlo decide bajo que categoría hacerlo. Elija una de la facilidad específica o un comodín. Prioridad Las prioridades de registros disponibles son (ordenadas por severidad) debug, info, notice, warning, err, crit, alert, emerg, panic Ellas determinan la severidad del mensaje. Elija una para registrar prioridades específicas o un comodín. Acción El campo de acción determina donde se coloca el registro. • Una ruta y un nombre de archivo en el campo de acción crea un registro en la máquina local. • Una @ en el campo acción indica que el registro será enviado a otro sistema a través de la red. El registro será enviado a la dirección que inmediatamente sigue la @. (Ej. @192.168.5.24). Si hacemos unos pequeños cambios en el archivo Syslog.conf puede direccional los registros otro sistema en vez de enviarlo a un archivo. En la próxima sección daremos un vistazo a como habilitar el sistema de login remotos. Login Remoto El syslogd contiene funciones que le permiten pasar los registros por la red entre sistemas que ejecutan syslogd. Si usted es responsable de varios sistemas, las capacidades de login remota pueden ahorrase mucho tiempo. Hay algunos pasos para la creación de registración remota: 1.- Cerciorarse de que el syslog esta definido en /etc/services para todos los sistemas. 2.- Configure syslog en cada máquina a comenzar a habilitar (registración) login remoto. 3.- Edite el archivo /etc/syslog.conf en las máquinas que exportaran sus registros. Mire en /etc/services. Para que syslogd comience a permitir login remoto, debe haber una entrada parecida a la siguiente: syslog 514/udp Después, usted necesitará tener que el syslogd arranque con logging remoto habilitado. Usted necesitará asegurarse que el programa del syslogd se invoque con la opción de -r: /usr/sbin/syslogd -r Algunas distribuciones ya se inicia con la opción -r, pero en algunas usted tendrá que agregarla manualmente en los scripts de arranque de algunas distribuciones. Finalmente, debes modificar el archivo /etc/syslogd.conf. Para que los registros se envíen a otra máqui na, se necesita agregar una entrada que le dice a syslog dónde

enviarlos. Lo que sigue es un ejemplo de esta entrada en el archivo /etc/syslog.conf de un sistema que se ha configurado para enviar los registros de todos sus eventos a otra máquina: *.* @una.maquina.com Esta entrada transmitirá todos los mensajes del syslog a una.maquina.com. En el sistema de recepción, las entradas del registro se mostrarán en /var/log/messages con la fecha, la hora, y el nombre del sistema que lo envió. Una de las aplicaciones principales de remote logging es que permite que usted instale un servidor dedicado que reciba todos los registros de todo el sistema de red. Esto proporciona una medida agregada de seguridad porque los intrusos no podrán cubrir sus pistas a menos que puedan comprometer el servidor de registro también. Un método aún más seguro es tener que todos los registros se impriman por una impresora. klogd GNU/Linux tiene una utilidad llamada klogd, con la única función de escuchar los mensajes producidos por el kernel. Los mensajes del Kernel son procesados dando los siguientes pasos: 1.- Una parte del Kernel hace una llamada para crear una entrada al registro del sistema. 2.- El klogd daemon recibe el mensaje desde /pro/kmsg donde el kernel lo ha hecho disponible a los programas externos. 3.- El campo de prioridad del mensaje se convierte del formato de mensajes del kernel (un dígito del 0 al 7) para hacerlo compatible con el del syslog. 4.- EL mensaje es enviado a syslogd donde es reconocido como un registro del sistema y procesado de tal manera. ADMINISTRACION DE LOS ARCHIVOS DE REGISTRO Los archivos de registro fueron diseñados para almacenar información del sistema en tiempo de ejecución. Estos archivos son generados para proveerle información necesaria. Si ustedes nunca lee esta información entonces no tienen sentido. Al analizar el registro, es importante saber quién se encuentra en ellos. Es de buena costumbre periódicamente analizar los archivos para así tener presente como lucen los registros cuando el sistema está normal. De esta manera, estarás más preparado cuando quiere localizar un problema. Los siguientes tópicos son discutidos en esta sección: • logger • lograte • xconsole Comando logger El programa logger ese es una simple herramienta que permite que puedas colocar mensajes estampados con la fecha en tus archivo /var/lo/messages. Es todo puede ser muy cursi y cuando quiere hacer un cambio fijo está seguro a trabajar. Y más adelante si ocurre un problema entonces podrá tener una referencia al porque dejo de funcionar. Utilizar logger es sencillo: $ logger Instale kbasic obviando dependencias… ha ver que pasa.:) Después al revisar el log veras el registro de esta manera:

Jul. 27 14:22:45 gnome2 gnome: Instale kbasic obviando dependencias… ha ver que pasa. :) El logger es muy facil de colocarle estampados de fecha a cambios ejecutados en caso de que después en el futuro causen problemas. La Herramienta lograte Los registros siempre están recogiendo información al menos que el sistema no este en completo reposo sin servicios en uso o activos. El archivo /var/log/messages es donde la mayoria de los mensajes de sistema se registran. Este archivo puede crecer rápidamente. Si se dejase solo, continuaría creciendo de tamaño hasta llegar a ser imposible para manejar. Muchos archivos del registro crecen excesivamente grandes si no se administran, así que es bueno tener herramientas como logrotate. El logrotate hace un trabajo excelente de mantener cosas en orden. El programa logrotate es una herramienta flexible que hace muchas cosas. Si las fechas de los registros caducan, pueden ser suprimidas automáticamente después de permanecer cierto tiempo en el sistema, si se ponen demasiado grande, puedan ser comprimidos. Si el sistema esta en una localización remota, los archivos de registro se pueden enviar a un administrador por e-mail. Usted puede modificar el comportamiento logrotate para requisitos particulares editando el archivo de logrotate.conf en el directorio /etc. Lo que sigue es una entrada de ejemplo de /etc/logrotate.conf: #Global Settings compress size=65k #settings individual “/var/Iog/wu-ftpd/access.log” { mail admin@abiertos.org size=150k nocompress endscript } Las primeras entradas en /etc/logrotate.conf son definiciones de variables globales. Todos los registros las utilizarán, salvo que se especifique lo contrario en una entrada separada. La segunda entrada es para un archivo de registro específico, en este caso, archivo /var/log/wu-tpd/access.log. Las acciones que logrotate tomará son las siguientes: • size Logrotate procesara los registros una vez adquieran el tamaño definido. • compress Registros son comprimidos durante su proceso. • nocompress Esta opción no comprimirá durante el proceso. • mail Los archivos de registro serán enviados a este correo una vez procesados. En este ejemplo del archivo logfile.conf define las acciones específicas para un archivo, Access.log. La definición comienza con la localización del archivo del registro (o del directorio por completo de los archivos del registro) entre las comillas dobles, seguidas por una llave abierta. La definición termina con la palabra clave endscript y entonces una llave de cierre. Toda entre estas llaves es la accion específica a este archivo de registro. Los cambios en las definiciones globales dan efecto par que el archivo

Access.log no se le efectue ninguna compresión y los registros se enviarán a admin@codigolibre.org. Algunos registros son más importantes que otros dependiendo de qué función desempeñan en el sistema, es decir, web server, servidor de archivo, o de acceso multiusos de shell. El poder manejar archivos de registro sobre una base individual es útil cuando hay cosas específicas que usted necesita vigilar. Salida de mensajes del sistema a la consola generalmente significa que ha ocurrido acontecimientos importantes, a menudo eventos criticos del sistema. Normalmente, esto es adecuado para las operaciones de sistemas, pero si se encuentra trabajando en una seccion en el X, los mensajes pasaran desapercibidos por el usuario. Aquí es adonde la utilidad xconsole entra en juego. El programa xconsole proporciona una ventana a estas salidas. El archivo asociado a la consola es /dev/console. Para que esta consola funcione correctamen te en el X, este archivo de dispositivo especial debe ser leible por el usuario actual y el uso del comando chown puede ser necesario. Normalmente, el xdm y otros programas gráficos que manejan la conexión cambian la propiedad de la consola de sistema. Además, un terminal que es capaz de hacer salida de los mensajes de consola puede ser logrado invocando el siguiente comando: # xterm -C La consola de sistema es una parte importante del sistema para mantener su integridad, porque actúa como un portavoz para las emergencias del sistema. Es altamente recomendado que usted utilice el xconsole o una consola virtual dedicada para estos mensajes de emergencia.

Resumen de Comandos $ watch -n tiempo comando Ejecuta un comando cada x segundos (2 por defecto). $ watch -n 1 date Igual que date pero en este caso veríamos correr los segundos. $ clear Limpia la pantalla. $ reset Restaura la Consola.Útil para cuando empiezan a aparecer caracteres raros. $ uname –a Versión del kernel $ hostname Visualiza el nombre de la máquina. $ tty Muestra el nombre de fichero de la terminal conectada a la salida estándar. # /etc/init.d/servicio stop Para un servicio/demonio # /etc/init.d/servicio start Inicia un servicio/demonio. # /etc/init.d/servicio restart Reinicia un servicio/demonio. $ startx Arranca el entorno gráfico con el gestor especificado en el .initrc de tu home. $ startx /usr/bin/X11/icewm Arranca el entorno gráfico con el icewm (si es que no fuera el predeterminado) $ Ctrl+C Termina un proceso. $ Ctrl+Z Suspende temporalmente la ejecución de un programa. $ Ctrl+S Para la transferencia de datos a la terminal. $ Ctrl+Q Resume,reinicia la tranferencia de datos $ Ctrl+R Entra en modo de busqueda incremental de linea de comandos, ej: Si entras en el modo y escribis "ls" (sin comillas) te completará la entrada más reciente que empiece por "ls", para ir rotando por la entradas antereriores seguir presionando Ctrl+R, para terminar presionar alguna flecha. $ Ctrl+L Limpia la pantalla. $ Ctrl+O Ejecuta un comando (como si se hubiera presionado ENTER) pero vuelve y deja el comando escrito en el prompt. $ Ctrl+K Borra desde donde está el cursor hasta el final. $ Ctrl+W Borra desde donde está el cursor hasta el inicio de la palabra debajo de èl.

$ Ctrl+E Salta al final de lo que se esté escribiendo. $ Ctrl+Alt+F2 Salir del entorno gráfico a un terminal.(Fnº según gettys activados en /etc/inittab) $ Ctrl+Alt+Supr Estando en una terminal reinicia (si no se indica otra cosa en /etc/inittab) $ ./script Ejecuta un script de shell. $ java -jar fichero.jar Ejecuta un programa java. $ consolechars -f fuente.psf.gz Cambiar la fuente de la consola.Las fuentes se encuentran en /usr/share/consolefonts/ $ base-config Configura el sistema base. $ gpm Programa que da soporte de ratón a la consola y aplicaciones que corren sobre ella. $ reportbug Programa en modo texto para enviar bugs a Debian $ exit Termina la ejecución del programa en curso. # init 0 Apaga la máquina. # init 6 Reinicia la máquina. # shutdown -t1 -h now Apaga la máquina . # shutdown -t1 -r now Reinicia la máquina. $ su Entrar a la sesión como root u otro usuario. # su nom_usuario Estando como root entramos como otro usuario. $ passwd Cambio de contraseña. $ who -a –H Muestra información de los usuarios conectados al sistema. $ users Muestra información de los usuarios conectados al sistema. $ id Muestra información del usuario actual,(grupos a los que pertenece,uid,gid) $ groups Muestra los grupos a los que pertenece un usuario.

# adduser usuario Crea un nuevo usuario. # adduser usuario grupo Añade un usuario existente a un grupo ya existente. # adduser --no-create-home usuario Crea un usuario pero sin directorio personal(home). # addgroup grupo Crea un nuevo grupo. # deluser usuario Elimina un usuario. # deluser usuario grupo Elimina un usuario del grupo especificado. # deluser --remove-home usuario Elimina un usuario y su directorio home. # delgroup grupo Elimina un grupo. # delgroup grupo --only-if-empty Elimina un grupo sólo si no tiene ningún usuario. # usermod -l nuevo_login Cambia el nombre del usuario. Sería bueno combinarlo con -d # usermod -d nueva_home -m login Cambia el home al usuario,creándolo si no existiese y transfiriendo el contenido. # usermod -e 2006-04-14 login Fecha en que la cuenta del usuario será desactivada,expresada en formato AAAA-MM-DD # groupmod -n nuevo_nombre grupo Cambia el nombre de un grupo. Usando el gestor de arranque (NTloader) de windows: Se copian los sectores de arranque de las particiones al archivo debian_sarge.lnx: # dd if=/dev/hda2 of=/debian_sarge.lnx bs=512 count=1 (tenemos sarge en hda2 con lilo o grup) # dd if=/dev/hda5 of=/debian_etch.lnx bs=512 count=1 (tenemos etch en hda5 con lilo o grup) los archivos debian*.lnx se copian en la partición raiz de windows y al archivo boot.ini de windows,oculto y de sólo lectura,le agregamos las siguientes lineas dentro de su sección [operating systems]: C:\debian_sarge.lnx="Debian Sarge" C:\debian_etch.lnx="Debian Etch" Atención:

cada vez que modifiquemos los sectores de inicio o gestores de arranque de las particiones linux habrá que volver a realizar lo anterior ya que los ficheros .lnx habrán quedado desactualizados. 5.b. Procesos y memoria Memtest86+ Realiza una comprobación del estado de la memoria si optamos a ello desde los gestores de arranque, para lo cual necesitamos editarlos añadiendoles su ruta. En lilo.conf: image = /boot/memtest86+.bin label = memtest86+ En menu.lst: title memtest86+ root (hd0,0) kernel /boot/memtest86+.bin suponiendo que /boot esté en la partición raiz (/) # make-memtest86+-boot-floppy Crea un disquete de arranque desde el que se ejecutará memtest86+ $ free -m -s 3 Muestra el uso de memoria. $ ps aux Muestra información de los procesos en curso. $ top Muestra información de los procesos en curso.(tecla z colorea los activos) $ pstree Muestra los procesos en curso en árbol. $ pidof comando Busca el ID de un programa que se está ejecutando. $ killall proceso Para un proceso. $ strace comando Muestra las llamadas al sistema originadas por un proceso. $ fuser -v archivo Muestra los procesos que están usando un fichero o directorio. $ lsof | less Lista los ficheros abiertos por los procesos, en realidad descriptores de ficheros $ lsof -c comando Lista los ficheros abiertos por un proceso. $ lsof +D /home/paco Lista los procesos que están usando mi directorio. $ lsof -i :60627 Muestra que proceso se encuentra detrás del puerto 60627 (aunque esté a la escucha) $ nohup comando & Lanza un proceso de forma que si cerramos el shell,el proceso continúa ejecutandose

$ comando & Ejecuta un comando en segundo plano(background),permitiendonos seguir usando el promp. $ jobs Lista los procesos en segundo plano identificándolos con un nº de tarea. $ fg nº Pasa a primer plano (foreground)un proceso $ bg Pasa a background un proceso que hemos suspendido temporalmente tecleando Ctrl-z $ nice -n prioridad comando Ejecuta un comando con una prioridad determinada(0 por defecto). Ejemplo: $ nice -n -10 cdrecord esos valores,de mayor a menor, son -20...+20, sólo root puede establecer valores negativos. $ renice prioridad PID_del_proceso Cambia la prioridad de un proceso en marcha $ sleep 5 comando Retarda 5 segundos la ejecución de un comando, m para minutos y h para horas. $ at [-f script] [tiempo] Ejecutar un script a una hora y/o fecha. Ejemplo $ at -f script 15:23 formas de indicar el tiempo: $ at -f script 15:23 hoy a las 15:23 $ at -f script 15:23 01.23.06 El 01.23.06 a las 15:23 $ at -f script now + 23 minutes Dentro de 23 minutos, puede ser minutes, hours, days, weeks $ at [tiempo] Ésta forma nos abre un promp interactivo. Ejemplo:

$ at 15:00 Abre el promp de at $ at > comando Ingresamos el comando/os. $ ctrl+d Salimos de at $ atq Muestra,numeradas,la lista de tareas programadas. $ atrm nº Eliminará una tarea identificada por su nº. $ batch Se emplea de las mismas formas que at,solo que en este caso, el script o comando se ejecutará sólo si la media de carga de la CPU es inferior al 80%. 5.c.-Disco duro Nomenclatura de dispositivos ------------------------------------------------------- | Nomenclatura de discos en linux| IDE | SCSI | | -------------------------------|-----------|----------| | Disco maestro del primer bus | /dev/hda | /dev/sda | | Disco esclavo del primer bus | /dev/hdb | /dev/sdb | | Disco maestro del segundo bus | /dev/hdc | /dev/sdc | | Disco esclavo del segundo bus | /dev/hdd | /dev/sdd | ------------------------------------------------------- Designacion de particiones ---------------------------------------- | disco /dev/hda |primarias | lógicas | | ----------------|----------|-----------| | 1ª partición |/dev/hda1 | /dev/hda5 | | 2ª partición |/dev/hda2 | /dev/hda6 | | 3ª partición |/dev/hda3 | /dev/hda7 | | 4ª partición |/dev/hda4 | /dev/hda8 | ---------------------------------------- $ du -h fichero Muestra espacio ocupado en disco,del directorio en curso si no indicamos nada. $ tree -a -s -L 2 tree es un programa que muestra lo mismo que du en forma de árbol. $ df

Muestra información sobre particiones montadas, con la opcion -h se muestra en formato Human Readable (e.g. KB, MB, GB). # cfdisk Muestra información sobre particiones.Herramienta para particionar en ncurses. # fdisk -l Muestra información sobre particiones.Herramienta para particionar. # mount Vemos el listado de dispositivos montados. # mount punto_montaje Monta un dispositivo.(ya establecido en el fstab) # umount punto_montaje Desmonta un dispositivo.(ya establecido en el fstab) # mount -t sistema_archivo dispositivo punto_montaje Monta un dispositivo. Ejemplo: # mount -t ext3 /dev/hda2 /mnt Donde se monta la segunda partición primaria del dispositivo /dev/hda, la cual es de tipo ext3, en el directorio /mnt # umount /dev/hda2 Desmonta un dispositivo # fsck /dev/hdax Chequea y repara el sistema de archivos de una partición NO MONTADA. # fsck.ext2 -vpf /dev/hdx Chequea y repara el sistema de archivos de una partición ext2 NO MONTADA. # fsck.ext3 -vpf /dev/hdx Chequea y repara el sistema de archivos de una partición ext3 NO MONTADA. # mkfs.ext2 /dev/hdb1 Crea un sistema de ficheros Linux ext2 en la primera partición del segundo disco duro. # mkfs.ext3 /dev/hdb1 Crea un sistema de ficheros Linux ext3 en la primera partición del segundo disco duro. # mkfs.ext3 /dev/fd0 Crea un sistema de ficheros Linux ext3 en el floppy.

# mkswap /dev/hda2 Crea un sistema de ficheros Linux swap (intercambio) en hda2. # resize2fs -f /dev/hda2 Reajusta el tamaño del sistema de ficheros después de haber ampliado/reducido la partición/volumen # tune2fs -O ^has_journal /dev/hda2 Convierte hda2 de ext3 a ext2 # tune2fs -j /dev/hda2 Convierte hda2 de ext2 a ext3 # tune2fs -C 255 /dev/hda1 Fuerza a que se revise /dev/hda1 en el próximo reinicio (con fsck). Útil para revisar la partición raíz, que no se puede desmontar. # quota Programa que gestiona/limita el uso que hacen del disco los usuarios/grupos. 5.d.-Entorno $ locale Muestra la zona geográfica configurada. # dpkg-reconfigure locales Reconfigura los locales. # dpkg-reconfigure console-data Reconfigura el teclado. $ loadkeys ruta_mapa_teclado.gz Carga el mapa de teclado que le indicamos,que estará en:/usr/share/keymaps $ locale charmap Muestra el código de caracteres en uso. $ set Muestra las variables locales definidas $ env Muestra las variables de entorno definidas. $ export Muestra las variables de entorno declaradas.

$ export VARIABLE=valor Añadimos una variable.Con export EDITOR=nano establecemos nano como editor predeterminado. $ export VARIABLE= Eliminamos una variable dejando en blanco su valor. Para que las variables permanezcan de una sesión a otra hay que ponerlas en el archivo .bashrc de tu home. 5.e-Instalación de software Dpkg Herramienta de nivel medio para instalar, construir, borrar y gestionar los paquetes de Debian # dpkg -i paquete Instalación de paquetes .deb # dpkg -r paquete Desinstala un paquete. # dpkg --purge paquete Desinstala un paquete y sus archivos de configuración. # dpkg --force -r paquete Fuerza la desinstalación de un paquete.Más información: dpkg --force-help # dpkg --force-all -r paquete Fuerza aún más la desinstalación de un paquete.Su uso puede dañar el sistema. # dpkg -c paquete Muestra el contenido (ficheros) de un paquete. # dpkg -L paquete Muestra todos los ficheros que se instalaron con un paquete. # dpkg -S fichero Muestra a qué paquete pertenece un fichero. # dpkg --get-selections Muestra todos los paquetes instalados en el sistema. # dpkg-reconfigure paquete Reconfigura paquetes instalados.Ejemplo: dpkg-reconfigure locales Apt Herramienta Avanzada de Empaquetamiento (Advanced Packaging Tool) que gestiona el sistema de paquetes de Debian instalando,desinstalando, actualizando y configurando los mismos.

La sintaxis es: # apt-get [opciones] acción # apt-get update Descarga y analiza la lista de nuevos paquetes desde los repositorios del sources.list. # apt-get upgrade Actualiza todos los paquetes instalados(no instala ni elimina paquetes). # apt-get dist-upgrade Actualiza todos los paquetes resolviendo las dependencias. # apt-get install paquete/s Instalación de paquetes por red,con resolución de depencias. # apt-get -s acción Simula,sin llevar a cabo la acción. Por ejem: apt-get -s install paquete. # apt-get -d acción Sólo descarga los paquetes deb en /var/cache/apt/archives/ sin instalar o desinstalar nada # apt-get install --reinstall paquete Reinstala un paquete. # apt-get remove paquete/s Desinstala un paquete. # apt-get remove --purge paquete/s Desinstala un paquete y sus archivos de configuración. # apt-get clean Elimina todos los paquetes (.deb) descargados y almacenados en /var/cache/apt/archives/ Apt-cache Utilidad que manipula la caché de paquetes de APT en busca de información $ apt-cache search palabra Busca en los paquetes y en las descripciones la palabra. $ apt-cache show paquete Muestra la descripción completa del paquete $ apt-cache showpkg paquete Muestra su relación con otros paquetes.

$ apt-cache depend paquete Muestra las dependencias del paquete $ apt-cache rdepend paquete Muestra las dependencias inversas del paquete(cuales dependen de él) Apt-build Herramienta que no se limita a instalar un paquete deb sino que compila el tarball, crea el paquete deb y lo instala, quedando así integrado con apt. Lo que se consigue compilando es optimizar la ejecución de los programas en nuestro procesador, de hecho al instalarse pregunta por el tipo de procesador del sistema. Tiene las mismas opciones que apt como update, upgrade, install Ejemplo: # apt-build install mplayer Instala mplayer (el paquete del ejemplo no está escogido al azar¿?) y alguna más como word para recompilar todo. En este último caso hay que crear una lista con los paquetes a recompilar en /etc/apt/apt-build.list para lo cual nos puede servir el siguiente comando: # dpkg --get-selections awk '{if ($2 == "install") print $1}' > /etc/apt/apt-build.list Es aconsejable eliminar de dicha lista paquetes delicados como gcc, libc6 Aptitude Gestor de paquetes con algunas mejoras con respecto a apt como la instalación automática de los paquetes que sin ser dependencias forman parte de los sugeridos o recomendados y la autodesinstalación de los paquetes instalados en su momento como dependencias de otros (automáticamente en contraposición a manualmente),si ningún otro paquete| los necesitase.Se puede usar de forma interactiva si no se especifica ninguna acción o desde la linea de comandos,usando las mismas opciones y acciones de apt.La sintaxis es: aptitude [opciones] acción ejem.: aptitude -s purge firefox # aptitude update Descarga y analiza la lista de nuevos paquetes según los repositorios del sources.list. # aptitude safe-upgrade Realiza una actualización segura (no instala ni elimina paquetes). # aptitude full-upgrade Realiza una actualización,instalando y eliminando paquetes si fuera preciso # aptitude install paquete/s Instala/actualiza paquetes # aptitude reinstall paquete/s Reinstala un paquete

# aptitude remove paquete/s Elimina paquetes # aptitude purge paquete/s Elimina paquetes y sus ficheros de configuración # aptitude download paquete/s Se limita a descargar los paquetes deb al directorio en el que estamos. # aptitude hold paquete/s Bloquea paquetes # aptitude unhold paquete/s Desbloquea un paquete # aptitude unmarkauto paquete/s Desmarca paquetes como instalados manualmente # aptitude markauto paquete/s Marca paquetes como instalados manualmente (elegidos por nosotros) $ aptitude search expresión Busca un paquete por nombre y/o expresión $ aptitude show paquete Muestra información detallada de un paquete $ aptitude clean Elimina los ficheros .deb descargados Opciones: -s Simula las acciones, pero en realidad no las realiza. -d Sólo descarga paquetes, no instala o desinstala nada. -p Siempre pide confirmación de las acciones -y Supone que la respuesta a preguntas simples del tipo sí/no es «sí» -f Trata de arreglar paquetes rotos de forma agresiva.

-V Muestra la versión de los paquetes a instalar. -D Muestra las dependencias de los paquetes cambiados automáticamente. -t rama Establece la rama de Debian desde la que se instalan los paquetes Deborphan Muestra los bibliotecas (paquetes lib) huérfanas -a Muestra todos los paquetes huérfanos (que no dependen de ningún otro). -d Muestra también sus dependencias. -n Muestra los paquetes \"sugeridos\" y \"recomendados\" como dependencias. # deborphan -A paquete Ignora un paquete(buena opcion si tenemos mala memoria y queremos conservar un huérfano) # deborphan -R paquete Cancela la orden anterior,si el paquete es huérfano lo mostrará. # deborphan -L Lista los paquetes ignorados Orphaner Interfaz gráfica de deborphan, sin parámetros sólo mostrará paquetes lib. -a Muestra todos los paquetes huérfanos del sistema. Editkeep Interfaz gráfica que gestiona o edita la lista de paquetes ocultos de deborphan. Debfoster Programa que mantiene una lista de los paquete que fueron instalados como dependencias de otros.La primera vez que se ejecuta pregunta si quieres conservar los paquetes instalados(pregunta por todos),Puede ejecutarse de manera interactiva o bién directamente desde la linea de comandos para instalar o desinstalar paquetes. Localepurge Script que elimina e impide la instalacion de los locales y páginas man que no nos interesa tener en el disco.Al instalarlo nos da a elegir los locales y

si automaticamente impide la instalación de otros.El programa no se encuentra bién integrado con la gestión de paquetes de debian... Checkinstall $ ./configure $ make $ su # checkinstall Esta sucesión de comandos crean un paquete .deb, una vez descomprimido el tarball* y ubicados en el directorio recién creado (si es el caso). ./configure: comprueba si nos faltan dependencias y crea el archivo make.ini necesario para la compilación. make: compila el programa.(lo pasa a lenguaje máquina o binario) checkinstall: crea el paquete .deb *tarball: fichero comprimido con el código fuente del programa. Me parece mejor la idea de hacer un paquete deb que la de compilar un programa desde las fuentes, de ésta manera se puede instalar el programa mediante dpkg -i quedando totalmente integrado en el sistema y luego si queremos desinstalarlo lo tendremos también mucho más facil con dpkg -r fakeroot make-jpkg jre-linux.bin dpkg -i sun-j2re.deb Ésta sucesión de comandos nos instala el java de sun, quedando totalmente integrado en nuestro sistema. fakeroot es un programa normal, sin el bit setuid (ver chmod). No aumenta los privilegios de un usuario ni disminuye la seguridad del sistema. Se escribió específicamente para permitir que los usuario pudiesen crear paquetes deb sin tener privilegios de superusuario. make-jpkg viene en el paquete java-package y sirve para convertir en paquete deb el binario de sun que contiene la máquina virtual de java (jre). 6.Recuperación del sistema 7.a.-Usando knoppix live CD_knoppix # su desde knoppix CD nos convertimos en root. root@CD # cd / nos vamos a / del knoppix CD. root@CD # mount -t ext3 /dev/hdax /mnt/hdax montamos la partición en cuestión. root@CD # chroot /mnt/hdax nos introducimos en ella con chroot*

root@disco_duro # mount -t proc proc /proc puede ser necesario montar el sistema de ficheros proc. root@disco_duro # nano /etc/lilo.conf editamos lilo (o lo que sea necesario). root@disco_duro # /sbin/lilo ejecutamos lilo. root@disco_duro # umount -t proc proc /proc desmontamos proc root@disco_duro # exit nos salimos de chroot y por tanto del disco duro root@CD # umount -t ext3 /dev/hdax /mnt/hdax desmontamos la partición en cuestión. root@CD # exit salimos del root de knoppix. CD_knoppix $ volvemos al punto de partida. * La orden chroot lo que hace es situarte virtualmente en la partición que le indicas y a partir de ahí las ordenes que le pases a la consola se ejecutan en esa partición, es como si realmente estuvieras en esa partición. 7.b.-Creando un disquete de arranque/rescate Con lilo Tan fácil como copiar lilo.conf en un disquete e indicarle que arranque desde el mismo, para lo cual hay que cambiar la linea boot por: boot=/dev/fd0 Si teneis varias particiones,entre ellas alguna lógica debeis añadir al lilo.conf del disquete la opción: \"lba32\" para que pueda arrancarla. Con el programa mkboot Este programa viene en el paquete debianutils. mkboot, entre otras cosas, te copia el lilo.conf al disquete,pero la verdad es que yo sólo he conseguido que me funcionen los disquetes creados con mkboot,cambiando el lilo.conf que te crea por el original y realizando después las modificaciones que cuento más arriba.El mismo programa te explica cómo: # mount /dev/fd0 /mnt montamos el disquete.

# cd /mnt nos vamos a él. # nano lilo.conf editamos lilo.conf # lilo -C lilo.conf con -C le decimos que ejecute el lilo del disquete y no el de /etc/lilo.conf # cd .. nos salimos. # umount /dev/fd0 desmontamos el disquete. Con grub Éste no lo he probado pero por lo que he visto se trataría de copiar los ficheros stage1 y stage2 al disquete tal que así: # mkfs.ext3 /dev/fd0 formateamos el disquete. # mount -t ext3 /dev/fd0 /floppy lo montamos en /floppy. # cp /ruta_de_acceso/stage1 /floppy copiamos stage1 # cp /ruta_de_acceso/stage2 /floppy copiamos stage2 # cp /boot/vmlinuz /dev/fd0 si hay sitio se puede incluir el nucleo en el disquete. # umount /dev/fd0 se desmonts floppy sin sacarlo. # grub inicia la interfaz de comandos de GRUB grub> root (fd0) instala las herramientas de GRUB... grub> setup (fd0) ...en el MBR del disquete.

grub> quit salimos Cuando se arranque desde el disquete y aparecezca el interprete de comandos de grub hay que teclear: grup> root (fd0) grup> kernel /boot/vmlinuz root=/dev/hda2 # kernel de inicio y particion raiz grup> boot Con el NTloader de microsoft En el caso de que lo usemos para el inicio también podemos crear un disquete de arranque con el mismo.Para ello copiaremos los ficheros ocultos \"ntldr\" , \"ntdetect.com\" y \"boot.ini\" que se encuentran en el directorio raíz del sistema (normalmente C:).Ésto es lo que haría cualquier windosero, pero nosotros además,tendremos que copiar el o los ficheros con extensión .lnx que pusimos en la partición raiz. 7.c.-Copiando el MBS(Master Boot Sector)-sector de arranque maestro Ésto crea un archivo llamado mbr con los primeros 512 bytes de hda: # dd if=/dev/hda of=mbr count=1 bs=512 Para restaurar la tabla de particiones: # dd if=mbr of=/dev/hda 7.d.-Copiando el VBS(Volume Boot Sector)-sector de arranque de una partición Ésto crea un archivo llamado sector_arranque_hda2 con los primeros 512 bytes de hda2 # dd if=/dev/hda2 of=/sector_arranque_hda2 count=1 bs=512 Para restaurar el sector de arranque # dd if=sector_arranque_hda2 of=/dev/hda2 Cada vez que se modifique lilo o grup,habrá que realizar una nueva copia del MBR o el sector de arranque que incluya los cambios. Kernel ,logs y hardware $ uname -a Versión del kernel. $ cat /proc/version Versión del nucleo y compilador empleado. $ lsmod Lista los módulos cargados. $ cat /proc/modules Lista los módulos cargados.

$ lsmod | grep módulo Ver si está cargado el módulo. $ modinfo módulo Muestra información sobre un módulo. # modprobe módulo Inserta un módulo en el kernel cargando antes los módulos de los cuales dependa. # modprobe -r módulo Elimina un módulo del kernel y si procede los que dependen del mismo. # insmod módulo Inserta un módulo en el kernel. # rmmod módulo Elimina un módulo del kernel. # echo módulo >> /etc/modules Inserta un módulo en el kernel de forma permanente. # depmod módulo Comprueba las dependencias del módulo. # modconf Programa gráfico para listar,cargar y descargar módulos del kernel. # alsaconf Programa interactivo que detecta las tarjetas de audio y carga los modulos adecuados. # less /var/log/kern.log Mensajes del nucleo (solo root o algun usuario que pertenesca al grupo adm tiene acceso a los logs) # less /var/log/syslog Registro de mensajes relativos a la seguridad. # less /var/log/debug Registro de información de depuración de los programas. # less /var/log/messages Mensajes del sistema de carácter informativo. # less /var/log/user.log Información del usuario.

# less /var/log/XFree86.0.log Información sobre las X # less /var/log/Xorg.0.log Información sobre las X # less /var/log/auth.log Accesos al sistema(incluye los intentos fallidos). # last Lista los usuarios conectados/desconectados (fichero /var/log/wtmp). # lastb Muestra los intentos de conexión fallidos (fichero /var/log/btmp). # hdparm /dev/hda Verificar DMA # hdparm -I /dev/hdx Información sobre hdx # hdparm -d1 /dev/hdx Activar DMA en el disco duro o periférico. $ dmesg Ver la salida que el kernel produjo en el arranque. $ dmesg | grep hd Información sobre dispositivos IDE. # sensors-detect Detecta,instala y carga los sensores y los módulos necesarios(en un kernel 2.6) # sensors Tras ejecutar el anterior,muestra temperaturas, voltajes y revoluciones de ventilador. # lsdev Muestra información sobre los dispositivos(canales IRQ,DMA y puertos E/S que utilizan) # lspci Ver dispositivos conectados a la placa madre mediante un bus PCI. # lsusb Ver los buses USB y los dispositivos conectados a los mismos.

# cdda2wav -scanbus Comprobar el interfaz SCSI. # cdrecord -scanbus Comprobar el interfaz SCSI. $ cat /proc/meminfo Información sobre la memoria. $ cat /proc/cpuinfo Información sobre el procesador. $ cat /proc/devices Información sobre dispositivos en uso. Notas syslogd registra los mensajes que los programas y el sistema ofrecen. klogd es un demonio del sistema que intercepta y registra los mensajes del núcleo. lsdev viene en el paquete procinfo. sensors viene en el paquete lm-sensors. Dispositivo de bloques:aquellos que almacenan información en bloques de tamaño fijo, (cada uno con su dirección) y utilizan los buffers del sistema (memoria temporal), Dispositivo de caracteres: aquellos que envian o reciben un flujo de datos de forma secuencial y sus procesos de lectura/escritura no poseen buffer.por ej. el ratón DMA(Acceso Directo Memoria): es la manera en que los dispositivos se comunican directa- mente con la memoria sin intervención del procesador.Cada controlador dispone de una linea o canal DMA de acceso directo. IRQ (solicitud de interrupción): es la manera en que el controlador de un dispositivo solicita al procesador que le atienda porque va a comunicarle algún suceso,cada contro- lador tiene una linea IRQ distinta. IO Ports (puertos de entrada/salida): se trata de una abstracción (que se corresponde con un dispositivo)a través de la cual un dispositivo intercambia datos con el sistema. Tienen una dirección(en hexadecimal)que los identifica. 8. Redes # /etc/init.d/networking start Inicia los servicios de red. # /etc/init.d/networking restart Reinicia los servicios de red.

# /etc/init.d/networking stop Para los servicios de red. # ifconfig [interfaz opciones IP] Información y configuración de interfaces de red. # ifconfig Muestra el estado de los interfaces activos. # ifconfig -a Muestra el estado de todos los interfaces. # ifconfig ppp0 Muestra el estado de ppp0 # ifconfig eth0 up Activa eth0. # ifconfig eth0 down Cierra eth0. # ifconfig eth1 address 156.35... Asigna una dirección al interfaz especificado. # iwconfig Similar a ifconfig pero sólo para interfaces wireless # ifup interface Habilita la interface especificada,ejemplos: ifup eth0 ;ifup ppp0 # ifdown interface Deshabilita la interface especificada,ejemplos: ifdown eth0 ;ifdown ppp0 # dhclient eth0/eth1 Inicia conexión dhcp mediante el cliente dhcp-client. # pump -i eth0/eth1 Inicia conexión dhcp mediante el cliente pump. # pppoeconf Programa para configurar conexiones pppoe. # pppconfig Programa en modo texto para configurar una conexión ppp.

# pon Establece la conexión ppp a internet. # plog Monitoriza la conexión ppp. # poff Finaliza la conexión ppp a internet. $ finger usuario Informa sobre un usuario conectado al sistema. $ finger @servidor Informa sobre todos los usuarios conectados a un servidor (nombre o IP) $ finger usuario@servidor Informa sobre un usuario conectado a un servidor $ ping google.com Verifica la conexión,en este caso con www.google.com (Ctrl+Z pone fin) $ traceroute microsoft.es Muestra la ruta que los paquetes de datos han seguida hasta la máquina de destino. $ mtr rediris.es Combinación de ping y traceroute. $ whois esdebian.org Información sobre éste,nuestro dominio. $ host -v -a telefonica.com Determina la ip de un nombre o el nombre de una ip.(host -v -a 194.224.55.221) $ iptraf Monitoriza tráfico de redes(ncurses) # tethereal Versión para consola de ethereal,un analizador del tráfico de red (sniffer). # ettercap Sniffer/interceptor/logger para redes LAN con switchs basado en ncurses. $ nmap Escaner de puertos.

# fail2ban Escanea logs como /var/log/auth.log y banea las IP con demasiados errores de conexión. # snort Sniffer de paquetes y un detector de intrusiones en una red (NIDS). # aide Detector de intrusiones en un único Servidor, PC o host.(HIDS). # portsentry IDS que detecta escaneos de puertos y reacciona a un ataque. 3 chkrootkit Detector de rootkit. w3m,lynx,links,links2,elinks Navegadores web,elinks soporta SSL con lo que podremos acceder a correo web. Irssi,*censored*x,WeeChat-curses Clientes IRC( Internet Relay Chat) ) mutt,mush,pine,elm Clientes de correo(MUA). cabber Cliente jabber( protocolo libre para mensajería instantánea.) Centericq Cliente de mensajeria multiprotocolo (ICQ,Yahoo,AIM,MSN,IRC,Jabber) ncftp Cliente ftp (File Transfer Protocol) basado en ncurses ftp-ssl Cliente ftp con soporte de cifrado SSL y TSL.(dependiendo de la otra parte) telnet-ssl Cliente telnet(acceso remoto) con soporte de cifrado SSL,(dependiendo de la otra parte) ssh Cliente ssh (Secure SHell),acceso remoto cifrado,forma parte del paquete openssh-client

rtorrent, bittornado Clientes bittorrent.Bitornado es una versión mejorada del cliente homónimo bittorrent. $ talk usuario Entabla una conversacion con un usuario del sistema. $ talk usuario@sistema Entabla conversacion con un usuario de otro sistema(entre máquinas UNIX) $ mesg -n Anula la notificacion de comunicacion de talk o write $ mesg -y Habilita la llegada de notificaciones de talk o write $ write usuario Manda un mensaje a un usuario del sistema. $ netstat -napt Saber qué puertos tiene abiertos nuestro sistema n No resuelve las direcciones a sus nombres DNS. Esto hace más rápida la ejecución.< a Muestra todos las conexiones,incluídas las que están escuchando. p Muestra el número y nombre del proceso,dueño de dicha conexión. t sólo muestra conexiones tcp $ jigdo-lite fichero.jigdo Programa interactivo que permite la descarga y/o \"actualización\" de una imagen ISO; descarga los ficheros de una imagen ISO mediante wget, los une y forma al vuelo una copia de la imagen ISO original. Pero si ya tenemos una imagen en el disco o un CD, bastaría con indicarle la ruta a la misma para que se actualizara. Para ambos casos hay que descargar previamente los ficheros .jigdo y .template asociados a la imagen. $ jigdo-file Herramienta para generar los ficheros .jigdo y .template de una imagen

$ wget [opciones] URL Gestor de descargas. -p descarga web completa. -r recursivo. -k Convierte los enlaces absolutos en relativos. -c Reanuda la descarga de un fichero parcialmente descargado. -l6 profundidad de recursión (5 por defecto) -A formato formato para descargar. -nH hace que no se cree el subdirectorio localhost. --cut-dirs=n elimina n número de directorios dentro de la jerarquia. Ejemplo 1ºw $ get -A zip URL Bajaría todos los archivos zip de una página web. Ejemplo 2º: nos queremos descargar el manual nano.pdf que está en http://www.manuales.com/informática/editores/nano.pdf $ wget -nH --cut-dirs=2 http://www.manuales.com/informática/editores/nano.pdf nos bajaría sólo el manual sin crearnos ningún nuevo directorio en nuestra home. Ejemplo 3º: nos queremos bajar el manual de Arocena en formato html cuya primera página está en: http://usuarios.lycos.es/ortihuela/index.htm ,pues entonces: $ wget -r -nH http://usuarios.lycos.es/ortihuela/index.htm nos bajaría todo el contenido del curso (ficheros .html,.css,.jpg,etc) al directorio /ortihuela