https://manuais.iessanclemente.net/api.php?action=feedcontributions&user=Javierfp&feedformat=atomManuais Informática - IES San Clemente. - Contribuciones del usuario [es]2024-03-29T08:11:11ZContribuciones del usuarioMediaWiki 1.36.2https://manuais.iessanclemente.net/index.php?title=Archivo:Multitarea.jpg&diff=68250Archivo:Multitarea.jpg2020-10-18T17:51:20Z<p>Javierfp: Javierfp subió una nueva versión de Archivo:Multitarea.jpg</p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Xesti%C3%B3n_de_Procesos&diff=68249Xestión de Procesos2020-10-18T17:46:43Z<p>Javierfp: /* Concepto de Proceso */</p>
<hr />
<div>= Concepto de Proceso =<br />
<br />
* '''Definición''': Un proceso se define como una instancia de un programa en ejecución. Un programa es un archivo binario en algún tipo de almacenamiento masivo (persistente), sin embargo cuando ese programa necesita ser ejecutado es necesario que el Sistema Operativo le asigne los recursos necesarios y establezca el control pertinente sobre la ejecución del programa. A la abstracción generada por los Sistemas Operativos para gestionar el recurso de procesamiento (CPU) se le denomina proceso. En resumen, un proceso es una abstracción creada por el Sistema Operativo para representar un programa en ejecución. Mediante esta abstracción el Sistema Operativo puede controlar la ejecución del Proceso y asignarle y controlar el acceso a los Recursos.<br />
<br />
<br />
* '''Multitarea''': La característica principal que permite que en la actualidad los Sistemas Operativos resulten "útiles" es la capacidad de éstos de poder ejecutar varios procesos a la vez. A esta capacidad se la denomina Multitarea o Multiprogramación. Hace muchos años los Sistemas Operativos eran Monotarea, esto quiere decir que solamente podían ejecutar una tarea o proceso en el Sistema. Además esta tarea se ejecutaba de principio a fin, sin interrupción posible, de modo que no era viable el detener un proceso a mitad de su ejecución para pasar a ejecutar otro. Si por ejemplo, el proceso tenía que realizar una lectura de datos de un dispositivo externo, como una cinta, lo cual es tremendamente lento, el proceso debía esperar en estado de ejecución a que la operación de acceso terminara, mientras la CPU estaba prácticamente ociosa a la espera de los datos leídos de la cinta. El paradigma clásico de este tipo de Sistemas era MS-DOS. En este Sistema Operativo un único proceso controlaba la ejecución de comandos o órdenes por parte del usuario. El usuario introducía una orden y esta se ejecutaba de principio a fin, cuando la orden devolvía la respuesta al usuario éste recibía de nuevo el control de la terminal y consola y podía introducir el siguiente comando.<br />
<br />
En la actualidad los Sistemas Operativos son '''Multitarea''' y, por tanto, varios procesos pueden ejecutarse concurrentemente (aunque no simultáneamente porque el número de unidades de ejecución o CPUs está limitado por el hardware). Aún así es posible para el Sistema Operativo detener un proceso en medio de su ejecución y pasar a ejecutar otro. Más tarde el primero se podría volver a ejecutar en el mismo punto en el que fue interrumpido. En un sistema multitarea, el ejemplo anterior de la lectura en cinta se gestionaría deteniendo el proceso y pasando a ejecutar otro que pudiera utilizar la CPU mientras el primero espera la recepción de los datos leídos de la cinta. De este modo el uso de la CPU se vuelve mucho más eficiente y el sistema operativo consigue que los procesos avancen concurrentemente, sin que los recursos de la máquina sean desaprovechados. Al cambio del estado de ejecución de un Proceso por parte del Sistema Operativo para poder ejecutar otro distinto se denomina "Cambio de Contexto" y es el mecanismo fundamental que permite la ejecución de Sistemas Multitarea.<br />
<br />
[[Archivo:2-1.jpg]]<br />
<br />
<br />
* '''Asignación del tiempo de CPU en multitarea'''<br />
<br />
En el siguiente gráfico se ilustra el modo en que la CPU se "reparte" entre los procesos listos para ejecutarse. En este caso tenemos 3 procesos, de nombres A, B y C. Cada proceso se ejecutará durante un tiempo de CPU determinado y supervisado por el sistema operativo. El gráfico ilustra un intervalo de tiempo de ejecución de 1 segundo en una CPU arbitraria. Se menciona también la escala de tiempo significativa para la CPU mediante la identificación de un intervalo I de '''1x10E-9s''', es decir, una mil millonésima de segundo, o lo que es lo mismo, una escala de tiempo correspondiente a una frecuencia de '''1Ghz'''. Con esto quiere hacerse notar que para una CPU, actuando en esa escala de tiempo, 1 segundo es un intervalo temporal muy significativo, durante el que puede avanzar la ejecución de varios procesos en secuencia (en el ejemplo A, B y C, pero en la práctica pueden ser muchos más). De este modo, bajo la limitación de la percepción humana, que opera en la escala del segundo, '''la impresión subjetiva''' es que la CPU ejecuta "simultáneamente" varios procesos a la vez, cuando ésto realmente no es así.<br />
<br />
Durante la ejecución del mismo, el proceso:<br />
<br />
* Se bloquea en una operación de solicitud de Entrada y Salida: Como es el caso de B en el gráfico<br />
* Es detenido por el sistema operativo transcurrido un tiempo, siendo elegido otro proceso para continuar<br />
<br />
En cualquiera de los dos supuestos anteriores, entre la parada del proceso y la ejecución del siguiente proceso elegido, transcurre un tiempo necesario para que el sistema operativo detenga el proceso "saliente" y ponga en marcha el proceso "entrante". A este tiempo se le denomina '''cambio de contexto''' y durante éste el sistema operativo guarda la información de ejecución de los registros de la CPU del proceso saliente y recupera la información de ejecución de la memoria principal, cargándola en los registros de la CPU, para el proceso entrante.<br />
<br />
Otro aspecto importante es que, en caso de que un proceso se bloquee en espera de la realización de una operación de E/S, como le ocurre a B, no se podrá retomar la ejecución de ese proceso hasta que dicha operación haya concluido. Observamos un rectángulo rojo en el gráfico que identifica precisamente este hecho. La naturaleza "lenta" de las operaciones de E/S causan el mencionado bloqueo y para la CPU ese proceso simplemente se queda "fuera de juego" hasta que los datos de la operación de E/S estén en memoria, en caso de una operación de lectura, o haya concluido la operación de escritura, en caso de que la naturaleza de la operación de E/S fuera escribir información en un dispositivo. Cuando la operación concluye se avisa al sistema operativo, mediante una '''interrupción hardware''', para que cambie el estado del proceso bloqueado en esa operación a listo o "elegible" para continuar con su ejecución.<br />
<br />
[[Archivo:Multitarea.jpg]]<br />
<br />
<br />
* '''Modos de ejecución de la CPU''': Como es sabido la CPU tiene dos modos de ejecución, Modo Privilegiado (o Modo Kernel) y Modo No Privilegiado (o Modo Usuario). La diferencia principal es que en Modo Privilegiado el proceso en ejecución tendría acceso a todos los recursos hardware del Sistema. La política general en los Sistemas es que solamente el Sistema Operativo se pueda ejecutar en Modo Privilegiado y los programas y aplicaciones de usuario lo hagan en Modo Usuario. De este modo cuando un proceso de usuario necesita acceder a alguna característica de acceso a algún recurso del Sistema, como abrir un archivo, comunicarse con otro proceso, obtener más memoria, etc., deberá invocar al Sistema Operativo para que sea éste el que determine si se le concede o no lo solicitado. A este mecanismo, mediante el cual los procesos de usuario solicitan recursos al Sistema Operativo, se le denomina Llamada al Sistema.<br />
<br />
[[Archivo:1-17.jpg]]<br />
<br />
= Modelo de Procesos en ejecución =<br />
<br />
* '''Modelo simplificado de CPU virtual''': El Modelo de CPU virtual hace referencia a que con la Multitarea el Sistema Operativo ofrece al usuario la "ilusión" de que se están ejecutando sus procesos de modo exclusivo y dedicado en la CPU. Según este modelo, irreal pero simple (esta es una de las funciones del Sistema Operativo, ofrecer al usuario una visión de Máquina Extendida), los usuarios percibirían como sus procesos avanzan en su ejecución sin tener que preocuparse de cómo se controlan los Cambios de Contexto, es decir, la asignación de la CPU a otros procesos, típica de los Sistemas Multitarea. De este modo, se percibiría un CPU virtual por cada proceso, cuando realmente lo que ocurre es que la Unidad de Ejecución (o Unidades de Ejecución en Sistemas Multicore) se comparte, entre todos los procesos que se pueden ejecutar.<br />
<br />
* '''Estados de los procesos:''' Mediante este concepto el Sistema Operativo puede organizar los Cambios de Contexto y decidir acerca de que proceso pasará a ejecutarse a continuación. Existen modelos de Estados de Procesos de hasta 7, o más, estados, sin embargo con un modelo básico de 3 estados podemos explicar fácilmente este concepto.<br />
Los 3 estados mencionados son:<br />
'''Ejecución''': Proceso que se está ejecutando en la CPU<br />
'''Listo''': Proceso que podrá ejecutarse cuando el Sistema Operativo le ceda turno y le asigne la CPU<br />
'''Bloqueado''': Proceso que no puede seguir ejecutándose, es decir pasar a Listo, hasta que no ocurra algún evento por el que está esperando, como por ejemplo la lectura de un archivo del Disco a la Memoria RAM.<br />
<br />
[[Archivo:2-2.jpg]]<br />
<br />
* '''Creación y Terminación de Procesos''': Las acciones de creación y terminación de procesos, como todo, es labor del Sistema Operativo. Cuando se crea un proceso se le asignarán recursos de ejecución e información de control que el Sistema Operativo utiliza para que el proceso pueda ejecutarse. Del mismo modo, al destruir un proceso el Sistema Operativo tendrá que liberar aquellos recursos, estructuras de control y datos que el proceso necesitaba para su ejecución.<br />
'''El Sistema Operativo puede crear procesos cuando:'''<br />
Se inicie el Sistema<br />
Otro proceso o un usuario del Sistema lo solicite<br />
'''El Sistema Operativo terminará un proceso cuando:'''<br />
Finalice correctamente su trabajo<br />
Se produzca algún error previsto que le impida seguir su ejecución<br />
Se produzca un error excepcional no previsto que haga que el proceso no pueda continuar<br />
Se apague el Sistema<br />
<br />
* '''Jerarquía de Procesos''': La naturaleza de las interrelaciones de procesos es compleja y dependiente del contexto, no funciona igual en todos los Sistemas Operativos. Es común, como en el caso de los Sistemas basados en UNIX/Linux, que exista una jerarquía de procesos, de modo que un proceso "padre" puede crear otros procesos "hijos". El modelo padre-hijo simplifica el proceso de creación de procesos y permite estructurar de un modo sencillo los procesos en el Sistema. Un proceso padre controla a todos sus hijos, si el padre es destruido todos sus hijos desaparecen con él, al revés no. Otros Sistemas Operativos, como Windows, no utilizan directamente el concepto de Jerarquía de procesos, en el sentido padre-hijo, aunque sí reconocen relaciones de dependencia entre procesos.<br />
<br />
= Implementación de Procesos =<br />
<br />
* '''Tablas de Control de Procesos''': Los Cambios de Contexto dentro del Sistema Operativo, esto era la conmutación del Estado de ejecución de un proceso a otro, que permitía implementar la Multitarea, requieren que un proceso en ejecución se detenga en un instante determinado y más tarde, tras que uno o más procesos se ejecuten el tiempo que determine el Sistema Operativo, retome su estado de ejecución exactamente en el mismo punto en el que se detuvo. Recordemos que cuando un proceso se ejecuta en la CPU escribe en los registros de la Unidad de Control y la ALU la información relativa a su estado de ejecución (Contador de Programa, Puntero de Pila, Registro de Instrucción, Registro de Estado, Segmentos de Direccionamiento, etc). Toda esa información deberá almacenarse en un lugar seguro para más tarde poder ser recuperada y reincorporada a los registros de la CPU, para de este modo continuar su ejecución en el mismo punto en el que se detuvo. Este lugar "seguro" es la '''Tabla de Procesos''', una estructura mantenida por el Sistema Operativo, en general en la Memoria RAM, con copia en disco. Por tanto, la Tabla de Procesos es la estructura dentro del Sistema Operativo que ayuda a organizar y controlar los Estados de los Procesos, mediante el almacenamiento en ella de toda la información de ejecución sobre el proceso que el Sistema Operativo necesita conocer. A continuación podéis ver un esquema de la información mantenida por la Tabla de Procesos del Sistema Operativo, en ella puede observarse como se guarda información de gestión de los Procesos, pero también de la Memoria y de los Archivos<br />
<br />
[[Archivo:2-4.jpg]]<br />
<br />
* '''Interrupciones y Cambios de Contexto''': Entonces, según lo anterior parece que todo funciona coordinado y controlado por el Sistema Operativo, ¿no?. La respuesta es claramente afirmativa. Pero, hay que tener en cuenta lo siguiente: El Sistema Operativo es un proceso más dentro del Sistema, entonces, ¿cómo es posible que el Sistema Operativo determine cuando un proceso es detenido para darle paso a otro en el momento en que otro proceso está en ejecución?. La respuesta está en el mecanismo de Interrupciones del hardware. Una Interrupción es un evento hardware que produce una respuesta de atención automática por parte de la CPU cuando esto ocurre. Abreviadamente, la CPU comprueba en cada ciclo de instrucción si se ha habilitado alguna línea de Interrupción directa o indirectamente conectada. Si la respuesta es negativa continúa con la siguiente instrucción del proceso en ejecución; si resulta que ha ocurrido una interrupción y se ha activado una de esas líneas, entonces, tiene que interrumpir el proceso en ejecución y atender a la causa de esa Interrupción.<br />
Por ejemplo, cuando un proceso necesita acceder al contenido de un archivo en disco, éste, para poder ser procesado deberá leerse del disco y copiarse total o parcialmente en la memoria RAM. Las lecturas de disco son tremendamente lentas en comparación con la velocidad de ejecución de la CPU y la Memoria principal, así que, lo que ocurre, es que el proceso se bloquea y espera a que el contenido del archivo esté accesible en RAM. Cuando el disco termina de copiar los datos a la RAM, debe indicar de algún modo a la CPU que el proceso ya está listo para poder continuar (es decir para que haga una transición del estado Bloqueado a Listo). El modo de conseguirlo es la emisión de una Interrupción que notifique a la CPU directamente, e indirectamente al Sistema Operativo, de que el proceso ya puede continuar. Ahora bien, ¿qué ocurriría con un proceso que está ejecutándose y no emite ningún tipo de petición bloqueante, como la lectura de un archivo del disco o el acceso a algún recurso ocupado o que lo haga bloquearse?. La respuesta, en principio, sería que ese proceso continua su ejecución hasta que termine. El caso es que esta política no es buena para Sistemas Operativos Multitarea, pues correríamos el riesgo de que un proceso monopolice el uso de la CPU y otros no puedan ejecutarse periódicamente. Para evitar esto, el hardware, el reloj concretamente (Real Time Clock, RTC), emite periódicamente una señal de Interrupción que hace que el Sistema Operativo se ejecute para controlar la situación anterior. De este modo es posible asignar tiempos de ejecución máxima de los procesos durante los cuales podrían ejecutarse sin que otros los releven, salvo que se bloqueen claro. A este tiempo de ejecución máxima se le denomina '''quantum''' y es un parámetro utilizado por la mayoría de Sistemas Operativos para controlar la Multitarea.<br />
En resumen, las Interrupciones son los puntos de unión del Hardware con el Software, es decir, el Sistema Operativo controla todo el Sistema de Ejecución de procesos en la medida en que es el que recibe y controla las Interrupciones.<br />
<br />
[[Archivo:interrupts.gif]]<br />
<br />
== Algoritmos de Planificación de Procesos ==<br />
<br />
El requisito de multiprogramar varios procesos en un único procesador lleva a la necesidad de definir estrategias para realizar tal operación. Existen varias aproximaciones y soluciones a esta cuestión, materializadas en una serie de algoritmos de planificación o calendarización. El módulo del Sistema Operativo encargado de realizar este trabajo se denomina '''planificador o calendarizador'''.<br />
<br />
Existen varios objetivos o metas que es persiguen a la hora de definir un algoritmo de planificación, algunas de ellas son:<br />
<br />
* '''Equidad''': Procesos equivalentes deben obtener un servicio similar<br />
* '''Tiempo de respuesta''': El tiempo de respuesta es el tiempo que transcurre entre la petición de un usuario interactivo y la respuesta a esa petición por parte del sistema. El objetivo, como es natural, será minimizar el tiempo de respuesta<br />
* '''Tiempo de retorno''': Tiempo transcurrido desde la llegada de un trabajo por lotes (no interactivo) al sistema y su finalización completa<br />
* '''Rendimiento''': Maximizar el número de trabajos terminados por unidad de tiempo<br />
* '''Eficiencia''': Mantener ocupada a la CPU el 100% del tiempo<br />
<br />
Un buen algoritmo de planificación debe conseguir de un modo sencillo y flexible esos objetivos. Existen una gran cantidad de algoritmos de planificación que han sido implantados y utilizados a lo largo de la historia de la computación, veremos a continuación algunos de los más significativos.<br />
<br />
* '''Primero en llegar, Primero en ser atendido (FCFS, First Come First Served)'''<br />
Este algoritmo procesa los trabajos (o procesos) a través de una cola simple. Cuando un proceso se crea en el sistema se pone en la cola de procesos Listos para ejecutarse y espera su turno. La ventaja de este algoritmo es su sencillez pero es muy ineficiente pues el procesador no puede ser entregado a otro proceso mientras el proceso actual no termine, incluso si se bloquea. Por tanto FCFS no es adecuado para la multiprogramación.<br />
'''NOTA''': Aquellos algoritmos que permiten que un proceso se detenga, es decir pasar a estado bloqueado o listo, antes de que finalice su ejecución se dice que son algoritmos con '''expropiación'''. Los algoritmos que requieren que los procesos se ejecuten de principio a fin, sin cambios de contexto se dice que son '''sin expropiación'''<br />
* '''Trabajo más corto primero (SJF, Shortest Job First)'''<br />
En los tiempos de los sistemas por lotes, cuando no había usuarios que trabajaban en modo interactivo, y menos con interfaces gráficas de usuario, interesaba terminar el mayor número de trabajos por hora, aumentando el rendimiento y obteniendo un tiempo medio de retorno óptimo. <br />
Este algoritmo consiste en seleccionar, de los procesos Listos en el sistema, aquel cuyo tiempo de ejecución será menor. Esto implica conocer de antemano el tiempo de ejecución de un proceso, información que en sistemas por lotes puede ser determinada por la experiencia previa. La desventaja principal de este algoritmo es que discrimina a los procesos con tiempo de ejecución mayor y si en el sistema existen muchos procesos con bajos tiempos de ejecución, la demora de los más largos puede ser insostenible.<br />
* '''Turno Rotatorio (RR, Round Robin)'''<br />
Este algoritmo es una versión expropiativa (en el sentido de que el Sistema Operativo expropia el procesador a los procesos) de FIFO, los procesos se mantienen en una cola de procesos Listos, esperando su turno para ejecutarse. Sin embargo, cuando un proceso se bloquea, o cuando transcurre un tiempo máximo preestablecido (denominado quantum), el Sistema Operativo otorga el procesador a otro de los procesos Listos, de este modo se dinamiza la ejecución de los procesos, optimizando la utilización del procesador y operando el sistema en modo multiprogramado.<br />
El período máximo de ejecución de un proceso, quantum, suele ser un parámetro configurable por parte del Sistema Operativo. Un quantum largo, por ejemplo 300 ms (pensemos en que los procesadores actuales trabajan en escalas de tiempo de nanosegundos, es decir la millonésima parte de un milisegundo), puede provocar que los procesos a la espera de ejecutarse sufran demoras importantes y en sistemas interactivos puede dar la impresión de lentitud en la respuesta del sistema.<br />
Por el contrario, un quantum corto, por ejemplo 20 ms, provocaría que los cambios de contexto entre procesos (operación que vimos que era costosa en términos se rendimiento) fuesen demasiado frecuentes, sobrecargando el sistema y manteniendo al procesador inactivo. Es por tanto necesario elegir un valor de quantum adecuado para el sistema. En la práctica, en sistemas interactivos, suelen utilizarse períodos de quantum en torno a los 50 ms.<br />
* '''Colas de Prioridad'''<br />
Una generalización de Turno Rotatorio surge al introducir el concepto de prioridad de un proceso. En el sistema se mantienen varias colas de procesos, una para cada nivel de prioridad de los mismos.<br />
Este algoritmo elige para ejecutar a continuación aquel proceso Listo dentro de la cola de mayor prioridad según un esquema de turno rotatorio, es decir con quantum y expropiación. Cuando los procesos Listos de una cola de máxima prioridad estén todos bloqueados o hayan terminado su ejecución se procederá a seleccionar procesos Listos de la cola de prioridad inmediatamente inferior.<br />
Este algoritmo suele perjudicar aquellos procesos de menor prioridad, por ese motivo es común que las prioridades sean dinámicas y el Sistema Operativo las vaya actualizando periódicamente a lo largo de la ejecución de un proceso.<br />
* '''Otros'''<br />
Otros algoritmos, menos utilizados: Calendarización garantizada, Calendarización por lotería, Tiempo restante de ejecución más corto, etc.<br />
<br />
= Modelo de Hilos y diferencia entre Proceso e Hilo =<br />
<br />
* '''Definición y diferencia entre Hilo y Proceso''': En los Sistemas Operativos actuales se utilizan dos conceptos similares, aunque diferentes, a la hora de gestionar la ejecución de procesos. Por un lado el concepto de proceso mismo se utiliza como unidad de asignación de recursos y se usa el término hilo (thread o subproceso) para hacer referencias a las unidades de ejecución de un proceso. En general un proceso consta de varios hilos de ejecución. Cada hilo de ejecución de un proceso se ocupa de realizar alguna tarea específica en relación al proceso. Estructurar los proceso en hilos mejora el rendimiento general del Sistema y hace más flexible y cómoda la programación eficiente de ciertas tareas. Por tanto siempre que usemos un punto de vista centrado en los recursos de los procesos (espacio de direcciones, archivos que utiliza el proceso, archivos de dispositivos, señales, estructuras compartidas, etc.) estaremos manejando implícitamente la noción de proceso. Cuando pensemos en la ejecución de un proceso, es decir, los aspectos relacionados con el tiempo durante el cual el proceso que se ejecuta en la CPU estaremos manejando la noción de hilo(s). En resumen, los hilos son los "subprocesos" de un proceso que se envían a ejecución a la CPU, por tanto un proceso puede constar de varios hilos y los recursos que comparten esos hilos, es decir el contexto que integra todos los hilos es el proceso en sí. En la siguiente sección veremos un ejemplo.<br />
<br />
'''Información de control para procesos e hilos mantenidos por el Sistema Operativo:'''<br />
<br />
[[Archivo:2-7.jpg]]<br />
<br />
* '''Uso de Hilos''': Imaginemos una empresa en la que hay 20 técnicos informáticos y 1 administrativo. Esta empresa se parecería un poco a un Sistema que no distinguiera entre procesos e hilos, veamos porqué. Pensad que el administrativo es el encargado de recibir todas las peticiones de asistencia técnica de la empresa, por tanto, siempre que un cliente entre por la puerta es él el encargado de tomar nota de la incidencia y derivársela a uno de los técnicos para que la solucione. Si en un momento dado llegan muchos clientes y el administrativo está ocupado, por ejemplo atendiendo el teléfono, muy probablemente los técnicos estén gran parte de su tiempo sin hacer nada pues el administrativo no es capaz de procesar los clientes al mismo ritmo al que llegan. El problema en esta empresa es que hay un elemento "bloqueante" que supedita la prestación del servicio de asistencia técnica a su disponibilidad de tiempo libre. Esto es, más o menos lo que podría ocurrir en un Sistema Operativo con procesos de un solo hilo, en cierta medida ese único hilo sería como el administrativo del ejemplo anterior. Si pensamos que la solución al problema podría ser hacer que 4 o 5 de los técnicos hiciesen de receptores de incidencias, seguramente los técnicos estarían ocupados y no estarían ociosos esperando a recibir trabajo.<br />
Desde un punto de vista más técnico podría decirse que cuando un proceso emite una Llamada al Sistema (petición al Sistema Operativo para hacer algún tipo de tarea que el no puede realizar directamente al no ejecutarse en modo privilegiado) éste se bloque a la espera que el Sistema Operativo le otorgue lo que necesite (aquello para lo que emitió la llamada). Ciertas Llamadas al Sistema son bloqueantes y hacen que el proceso tenga que pasar a estado Bloqueado, deteniendo su ejecución y no pudiendo avanzar hasta que se complete la operación solicitada. Si dividimos un proceso en hilos es posible hacer que aunque uno de ellos se bloquee en espera de una Llamada al Sistema, otro hilo del mismo proceso pueda ejecutarse y hacer algún trabajo productivo para el proceso. Este es el objetivo principal y la causa de que exista el concepto de hilo en los Sistemas modernos. Además, como cada vez las CPUs son más rápidas, los procesos tienden a bloquearse muy rápido y a desperdiciar tiempo de CPU, aumentando los Cambios de Contexto. Los hilos ayudan a mejorar enormemente el rendimiento en estos casos.<br />
<br />
'''Gráfico de procesos e hilos dentro de un proceso:'''<br />
<br />
[[Archivo:2-8.jpg]]<br />
<br />
* '''Hilos en Espacio de Usuario y Kernel''': Existen dos modos de implementar la gestión de hilos en el Sistema Operativo. Bien en el espacio de usuario, como un programa, o mejor dicho una librería de soporte a los programas, o bien en espacio de kernel, es decir, como parte constitutiva del propio Sistema Operativo<br />
<br />
'''Ejemplo de uso de hilos en un proceso de servidor web:'''<br />
<br />
[[Archivo:2-10.jpg]]<br />
<br />
= Comunicación y sincronización entre Procesos =<br />
<br />
Los procesos utilizan los recursos del sistema bajo la supervisión y control del Sistema Operativo. En ocasiones ocurren conflictos derivados de la compartición de ciertos recursos entre los procesos. Por este motivo el Sistema Operativo debe de realizar una labor de arbitraje que evite que esa compartición origine problemas de consistencia en el sistema. Un ejemplo de esta situación lo constituyen los problemas de actualización concurrente de variables compartidas de memoria, a la cual pueden acceder varios procesos. Si no se controlan los accesos a esas variables ocurren problemas de inconsistencia y modificaciones perdidas del valor de la variable<br />
<br />
La solución pasa por delimitar claramente aquellas partes de un programa que acceden a recursos compartidos que pueden dar lugar a las denominadas '''condiciones de competencia o carrera''', término que indica la inconsistencia potencial derivada de compartir esa información. A las partes de un programa dónde se accede a información y recursos que pueden dar lugar a condiciones de competencia se las denomina '''secciones o regiones críticas''', siendo utilizados indistintamente ambos términos. Será labor del Sistema Operativo o del programador de aplicaciones garantizar la coherencia y consistencia del sistema derivado de las acciones de los procesos.<br />
Existen varias alternativas y aproximaciones para proporcionar una solución a este problema pero caen fuera del ámbito de este curso. En el libro Sistemas Operativos Modernos de Tanenbaum podéis encontrar más información.<br />
<br />
Otros contextos dentro relacionados con la Comunicación entre Procesos son los mecanismos de paso y compartición de información entre ellos. Existen muchos mecanismos que posibilitan esta compartición, como son el Paso de Mensajes, las Señales y las relaciones de tipo Padre-Hijo entre procesos en aquellos Sistemas Operativos que las soporta, como Linux.<br />
<br />
= Referencias =<br />
<br />
== Planificación de Procesos ==<br />
http://informatica.iessanclemente.net/manuais/index.php/Algoritmos_de_Planificaci%C3%B3n_da_CPU<br />
== Comandos de monitorización útiles para los Administradores ==<br />
http://www.cyberciti.biz/tips/top-linux-monitoring-tools.html<br />
<br />
Ilustraciones de A.S. Tanenbaum distribuídas con licencia [https://creativecommons.org Creative Commons]<br />
<br />
[[Xeneralidades dos Sistemas Operativos|Volver]]<br />
<br />
JavierFP 18:13 03 dec 2018 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Arranque._SysVinit&diff=67502Arranque. SysVinit2020-05-01T16:02:13Z<p>Javierfp: /* NOTA */</p>
<hr />
<div>== NOTA ==<br />
<br />
El sistema de gestión de servicios que se explica a continuación está "deprecated" (marcado como obsoleto) en la mayoría de distribuciones GNU/Linux, las cuales han optado por sustituir su gestión mediante el sistema '''systemd'''. Por cuestiones de compatibilidad algunas distribuciones todavía lo soportan, aunque la tendencia es su eliminación.<br />
<br />
== Inicio y parada Sysvinit ==<br />
<br />
Cuando un Sistema Linux arranca crea una serie de procesos automáticamente durante esa fase. Estos procesos serán el mínimo de servicios necesarios para que el sistema pueda funcionar adecuadamente. Es posible gestionar, es decir, añadir, eliminar y cambiar el orden en el que esos procesos se inician.<br />
Existe un proceso fundamental en todo Sistema Linux, el proceso init (inicio), cuya configuración nos permite establecer qué procesos serán los que se iniciarán durante el arranque. Del mismo modo se usa este mecanismo para especificar el orden de detención de éstos cuando el sistema se apague.<br />
<br />
=== Niveles de init ===<br />
<br />
Linux reconoce varios niveles, denominados '''runlevels''', que definen el perfil de arranque del sistema en ese nivel, es decir, qué procesos (servicios o demonios) se iniciarán cuando el sistema arranque. Por ejemplo, en Debian se reconocen los siguientes:<br />
<br />
<pre><br />
Nivel de ejecución 0: Apagado.<br />
Nivel de ejecución 1: Monousuario (sólo usuario root; no es necesaria la contraseña). Se suele usar para analizar y reparar problemas.<br />
Nivel de ejecución 2: Multiusuario sin soporte de red.<br />
Nivel de ejecución 3: Multiusuario con soporte de red.<br />
Nivel de ejecución 4: Como el runlevel 3, pero no se suele usar<br />
Nivel de ejecución 5: Multiusuario en modo gráfico (X Windows).<br />
Nivel de ejecución 6: Reinicio. <br />
</pre><br />
<br />
En el caso de arrancar en entorno gráfico debemos utilizar, como puede verse en el listado anterior, el Nivel de ejecución (runlevel) 5, pero no siempre es así, por ejemplo en Debian/Ubuntu el nivel de entorno gráfico es el 2. Por supuesto que cuando se arranca en nivel 1, 2 o 3, el número de procesos que se levantarán será diferente, al no ser usado en esos niveles el servidor gráfico X Window. Éste es el motivo por el cual disponemos de distintos runlevels.<br />
<br />
Comando para visualizar el nivel de ejecución de la sesión actual:<br />
<br />
<pre>runlevel</pre><br />
<br />
Puede especificarse un runlevel por defecto, es decir, aquel en el que el sistema arrancará al no especificar ningún nivel concreto. En los Linux desktop lo lógico es arrancar en runlevel correspondiente al entorno gráfico. Puede espeficiarse ésto en el archivo '''/etc/inittab''' (sino existe puede crearse) y añadir una línea del tipo en ese archivo:<br />
<br />
<pre><br />
id:5:initdefault:<br />
</pre><br />
<br />
En el caso de Ubuntu 12.04 no existe ese archivo, utiliza la configuración definida en el archivo '''/etc/init/rc-sysinit.conf'''.<br />
En cualquier caso el mecanismo es el mismo, buscar una línea en la que se indique la opción DEFAULT, en este caso la línea es:<br />
<br />
<pre><br />
env DEFAULT_RUNLEVEL = 2<br />
</pre><br />
<br />
=== Archivos de configuración de init ===<br />
<br />
Existe un diretorio, '''/etc/init.d''', dónde se incluyen distintos scripts de arranque y parada de procesos del sistema. Para verlos podéis hacer un ls -la /etc/init.d y observar el contenido de esa salida. Veréis que los archivos allí incluídos tienen permiso de ejecución. El objetivo de ésto es tener de un modo centralizado los scripts de control de todos aquellos procesos, para poder invocar su arranque, parada, reinicio, o recarga directamente desde /etc/init.d (start, stop, restart, reload). De este modo solo tenemos que recordar esa ubicación para poder saber cómo invocar a un script indirectamente.<br />
<br />
Paralelamente disponemos de los directorios '''/etc/rcN.d''' dónde N=0,1,2,3,4,5,6 indica el runlevel correspondiente.<br />
En estos directorios disponemos de enlaces simbólicos a los scripts dentro de '''/etc/init.d''' que se iniciarán en el arranque del runlevel correspondiente. Es decir en los directorios /etc/rcN.d tenemos enlaces simbólicos que apuntan por lo general a scripts de gestión de servicios en /etc/init.d.<br />
<br />
Hacemos un ls -la /etc/rc5.d<br />
<br />
[[Archivo:rc5.d.PNG]]<br />
<br />
Podéis ver en esa salida cómo todos los archivos de ese listado '''son de tipo link y apuntan a archivos dentro de /etc/init.d'''.<br />
Los links dentro de los directorios '''/etc/rcN.d tienen un código de denominación concreto'''. Pueden empezar por S o K, los que empiezan por '''S hacen referencia a procesos que arrancarán''' en el runlevel correspondiente. A continuación en el nombre va un número decimal de 2 dígitos que indica el orden, en una secuencia, en la que arranca el proceso. Por ejemplo un link con nombre S99xxx, arrancará después que un link con nombre S88xxx, pues el número 99 es mayor que 88 y la secuencia de arranque es creciente. Los enlaces cuyo nombre empieza por la letra K corresponde a aquellos servicios que serán detenidos (Kill) en el runlevel correspondiente.<br />
<br />
El proceso de arranque es el siguiente:<br />
Dado un runlevel concreto (N=0,1,2,3,4,5,6) se ejecutarán para todos los niveles anteriores, por ejemplo para N=2, 0 y 1, los scripts dentro de /etc/rcN.d. Es decir, para runlevel 2 se ejecutarán los scripts a los que apunta /etc/rc0.d, /etc/rc1.d.<br />
<br />
Dentro de estos directorios también existen links con nombre que empieza por K, seguidos de un número de secuencia de 2 dígitos. Éstos hacen referencia a aquellos procesos que se detendrán al iniciarse el runlevel correspondiente. En este caso el orden de ejecución es el inverso al de arranque, es decir, un link KXX con número de secuencia mayor se ejecutará antes que uno con número de secuencia menor.<br />
<br />
Desde la versión del 2009 Ubuntu ha empezado a migrar el mecanismo de arranque los servicios del sistema a una herramienta denominada '''upstart'''. En la actualidad utiliza un sistema híbrido, algunos servicios pueden ser procesados mediante upstart y también está soportada la posibilidad de utilizar el sistema de init.<br />
<br />
=== Uso del sistema de arranque init ===<br />
<br />
Podemos controlar y configurar el mecanismo de arranque de los servicios o demonios (daemons) directamente editando los archivos, links, de /etc/rcN.d, utilizando la convención denominativa SXX o KXX, o bien utilizando el comando '''update-rc.d'''.<br />
<br />
'''Ejemplo:'''<br />
Crear un link para que arranque el proceso con script en /etc/init.d/miprograma en el runlevel 2.<br />
<br />
<pre><br />
sudo ln -s /etc/init.d/miprograma /etc/rc2.d/S99miprograma<br />
</pre><br />
<br />
Al indicar un número de secuencia alto garantizamos que arrancará al final del proceso de arranque en el runlevel 2<br />
<br />
Utilizando el comando '''update-rc.d''' podemos hacer lo mismo pero sin necesidad de crear explícitamente el enlace simbólico. Además con update-rc.d podemos indicar la configuración para varios runlevels simultáneamente y configuración de arranque (start) y parada (stop).<br />
<br />
'''Ejemplos:'''<br />
Incorporar en arranque el servicio con script en /etc/init.d/miprograma para los niveles 0, 1 y 2 con secuencia 50:<br />
<br />
<pre><br />
update-rc.d miprograma start 50 0 1 2 .<br />
</pre><br />
<br />
Incorporar en arranque el servicio con script en /etc/init.d/miprograma para los niveles 2 a 5 con secuencia 40 y detención en los niveles 0 1 y 6:<br />
<br />
<pre><br />
update-rc.d miprograma start 40 2 3 4 5 . stop 40 0 1 6 .<br />
</pre><br />
<br />
Incorporar en arranque por defecto el servicio con script /etc/init.d/miprograma:<br />
<br />
<pre><br />
update-rc.d miprograma defaults<br />
</pre><br />
<br />
== Linux Standard Base (LSB) ==<br />
<br />
LSB es un estándar desarrollado por la Linux Software Foundation para reducir las diferencias en el modo de iniciar servicios en distintas distribuciones de Linux. Básicamente constituye un conjunto de reglas que deberían de cumplir todos los scripts relacionados con el arranque de servicios del Sistema.<br />
<br />
Las 3 reglas principales son<br />
* '''Todo script LSB debe proporcionar las opciones de invocación start,stop,restart,force-reload,status'''<br />
* '''Devolver un exit code (código de salida) en cualquier caso'''<br />
* '''Documentar las runtime dependencies'''<br />
<br />
Cada script de inicio tendrá una sección '''header''' que puede ser utilizada para gestionar dependencias con otros scripts, por ejemplo:<br />
<br />
<pre><br />
*** BEGIN INIT INFO<br />
* Provides: my_daemon<br />
* Required-Start: postgresql networking<br />
* Required-Stop: postgresql networking<br />
* Default-Start: 2 3 4 5<br />
* Default-Stop: 0 1 6<br />
* Short-Description: This is a test daemon<br />
* Description: This is a test daemon<br />
* This provides example about how to<br />
* write a Init script.<br />
*** END INIT INFO<br />
</pre><br />
<br />
En el ejemplo anterior vemos como la sección header especifica el nombre del servicio ofrecido por el script, '''Provides''', que será usado para hacer referencia a él por otros scripts. Las otras secciones especifican dependencias externas con otros scripts. Por ejemplo el '''Required-Start''' indica que para que el script inicie deberán ser previamente iniciados los scripts con sección '''Provides posgresql y networking'''. También indica en que runlevels arranca el servicio, '''Default-Start''', y en que runlevels debe ser detenido '''Default-Stop'''. Por último ofrece la posibilidad de ofrecer una descripción corta y larga del servicio, '''Short-Description y Description''' respectivamente.<br />
<br />
La información de la sección '''header''' será utilizada por comandos como '''update-rc''' e '''inserv''' para definir el modo de construir los enlaces en los directorios '''/etc/rcx.d''' según se vió en la sección anterior<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Comandos_para_a_administraci%C3%B3n_de_ficheiros_en_Linux&diff=67074Comandos para a administración de ficheiros en Linux2020-03-20T11:30:57Z<p>Javierfp: /* ls - touch - mkdir - ln */</p>
<hr />
<div>== Introdución ao sistema de ficheiros de linux==<br />
Para unha descrición completa do sistema de arquivos podemos poñer na nosa Shell o comando:<br />
<source lang="bash"><br />
$ man hier<br />
</source><br />
Así e todo, podemos ver na seguinte táboa un resumo da organización dos directorios nun sistema linux:<br />
{| border="1" cellspacing="0" cellpadding="5" <br />
! style="background:#ffdead;" | Directorio<br />
! style="background:#ffdead;" | Descrición<br />
|- <br />
| /bin/<br />
| Comandos e programas binarios esenciais (cp, mv, ls, rm, etc.),<br />
|-<br />
| /boot/<br />
| Ficheiros utilizados durante o arranque do sistema (núcleo e discos RAM)<br />
|-<br />
| /dev/<br />
| Dispositivos esenciais, discos duros, terminais, son, video, lectores dvd/cd, etc<br />
|-<br />
| /etc/<br />
| Ficheiros de configuración utilizados en todo o sistema e que son específicos do ordenador<br />
|-<br />
| /etc/opt/<br />
| Ficheiros de configuración utilizados por programas aloxados dentro de /opt/<br />
|-<br />
| /etc/X11/<br />
| Ficheiros de configuración para o sistema X Window (Opcional)<br />
|-<br />
| /etc/sgml/<br />
| Ficheiros de configuración para SGML (Opcional)<br />
|-<br />
| /etc/xml/<br />
| Ficheiros de configuración para XML (Opcional)<br />
|-<br />
| /home/<br />
| Directorios de inicio dos usuarios (Opcional)<br />
|-<br />
| /lib/<br />
| Bibliotecas compartidas esenciais para os binarios de /bin/, /sbin/ e o núcleo do sistema.<br />
|-<br />
| /mnt/<br />
| Sistemas de ficheiros montados temporalmente.<br />
|-<br />
| /media/<br />
| Puntos de montaxe para dispositivos de medios como unidades lectoras de discos compactos.<br />
|-<br />
| /opt/<br />
| Paquetes de aplicacións estáticas.<br />
|-<br />
| /proc/<br />
| Sistema de ficheiros virtual que documenta sucesos e estados do núcleo. Contén principalmente ficheiros de texto.<br />
|-<br />
| /root/<br />
| Directorio de inicio do usuario root (super-usuario) (Opcional)<br />
|-<br />
| /sbin/<br />
| Comandos/programas binarios de administración de sistema.<br />
|-<br />
| /tmp/<br />
| Ficheiros temporais <br />
|-<br />
| /srv/<br />
| Datos específicos de sitio servidos polo sistema.<br />
|-<br />
| /usr/<br />
| Xerarquía secundaria para datos compartidos de só lectura (''Unix system resources''). Este directorio pode ser compartido por múltiples ordenadores e non debe conter datos específicos do ordenador que os comparte.<br />
|-<br />
| /usr/bin/<br />
| Comandos/programas binarios.<br />
|-<br />
| /usr/include/<br />
| Ficheiros de inclusión estándar (cabeceiras de cabecera utilizados para desenvolvemento).<br />
|-<br />
| /usr/lib/<br />
| Bibliotecas compartidas.<br />
|-<br />
| /usr/share/<br />
| Datos compartidos independentes da arquitectura do sistema. Imaxes, ficheiros de texto, etc.<br />
|-<br />
| /usr/src/<br />
| Códigos fonte (Opcional)<br />
|-<br />
| /usr/X11R6/<br />
| Sistema X Window, versión 11, lanzamento 6 (Opcional)<br />
|-<br />
| /usr/local/<br />
| Xerarquía terciaria para datos compartidos de só lectura específicos do ordenador que os comparte.<br />
|-<br />
| /var/<br />
| Ficheiros variables, como son ''logs'', bases de datos, directorio raíz de servidores HTTP e FTP, colas de correo, ficheiros temporais, etc.<br />
|-<br />
| /var/cache/<br />
| Cache da datos de aplicacións.<br />
|-<br />
| /var/crash/<br />
| Depósito de información referente a caidas do sistema (Opcional)<br />
|-<br />
| /var/games/<br />
| Datos variables de aplicacións para xogos (Opcional)<br />
|-<br />
| /var/lib/<br />
| Información de estado variable. Algúns servidores como MySQL e PostgreSQL almacenan as súas bases de datos en directorios subordinados deste.<br />
|-<br />
| /var/lock/<br />
| Ficheiros de bloqueo.<br />
|-<br />
| /var/log/<br />
| Ficheiros e directorios de rexistro de sistemas (''logs'').<br />
|-<br />
| /var/mail/<br />
| Buzóns de correo de usuarios (Opcional)<br />
|-<br />
| /var/opt/<br />
| Datos variables de /opt/.<br />
|-<br />
| /var/spool/<br />
| Colas de datos de aplicacións.<br />
|-<br />
| /var/tmp/<br />
| Ficheiros temporales preservados entre reinicios.<br />
|-<br />
|}<br />
<br />
== pwd ==<br />
O comando [http://linuxcommand.org/man_pages/pwd1.html pwd] nos indica o directorio de traballo, é dicir, o directorio no que nos atopamos nese momento.<br />
<br />
== cd ==<br />
O comando [http://linuxcommand.org/man_pages/cd1.html cd] permítenos cambiar o directorio de traballo.<br />
* Direccións absolutas:<br />
<source lang="bash"><br />
usuario@1[~]$ cd /usr/lib/apache<br />
usuario@1[apache]$<br />
</source><br />
*Direccións relativas:<br />
<source lang="bash"><br />
usuario@1[Documents]$ cd ../Desktop<br />
usuario@1[Desktop]$<br />
</source><br />
<br />
== ls - touch - mkdir - ln ==<br />
O comando [http://manpages.ubuntu.com/manpages/hardy/man1/ls.1.html ls] permítenos visualiza-los directorios e ficheiros que hai dentro dun directorio (por defecto no directorio de traballo).<br />
<source lang="bash"><br />
# Listado normal:<br />
usuario@1[Documents]$ ls<br />
<br />
# Listado recursivo:<br />
usuario@1[Documents]$ ls -F -R<br />
<br />
# Listado completo con características dos ficheiros e directorios:<br />
usuario@1[Documents]$ ls -l<br />
<br />
# Mostra o tamaño en formato humano:<br />
usuario@1[Documents]$ ls -sh<br />
<br />
# Mostra os números de i-nodo dos ficheiros e directorios:<br />
usuario@1[Documents]$ ls -i<br />
<br />
# Mostra os ficheiros e directorios ocultos (emprezan por .)<br />
usuario@1[Documents]$ ls -a<br />
<br />
# Listado completo con características do arquivo "datos1", se existe:<br />
usuario@1[Documents]$ ls -l datos1<br />
<br />
# Listado completo con características dos arquivos que comezan<br />
# por "datos" e teñen un caracter mais ao final (só un caracter máis):<br />
usuario@1[Documents]$ ls -l datos?<br />
<br />
# Listado completo con caracteríticas dos arquivos que comezan<br />
# por "datos" e teñen cero ou máis caracteres ao final (os que sexan):<br />
usuario@1[Documents]$ ls -l datos*<br />
</source><br />
En linux existen catro tipos de ficheiros:<br />
* '''Ficheiros normais (-):'''<br />
: - Son ficheiros con datos, xa sexan de texto ou binarios. Teñen un nome e poden ter unha extensión, aínda que linux non asocia tipos de ficheiros nin aplicacións segundo as extensións dos mesmos.<br />
: - Podemos crear un ficheiro baleiro có comando [http://linuxcommand.org/man_pages/touch1.html touch].<br />
<source lang="bash"><br />
$ touch test1<br />
$ ls -il test1<br />
1954793 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:35 test1<br />
</source><br />
* '''Directorios (d):'''<br />
: - Os directorios en linux son ficheiros dun tipo especial, que como información conteñen unha lista de entradas cós números de i-nodo e nome dos ficheiros e directorios que conteñen (''táboa de entradas de directorio'').<br />
: -Para crear un directorio, usaremos o comando [http://linuxcommand.org/man_pages/mkdir1.html mkdir]:<br />
<source lang="bash"><br />
$ mkdir dir3<br />
$ ls -il<br />
total 16<br />
1954886 drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:42 dir1/<br />
1954889 drwxr-xr-x 2 usuario usuario 4096 Sep 1 10:55 dir2/<br />
1954893 drwxr-xr-x 2 usuario usuario 4096 Sep 1 11:01 dir3/<br />
1954888 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
1954793 -rw-r--r-- 1 usuario usuario 6 Sep 1 09:51 test4<br />
$<br />
</source><br />
* '''Dispositivos:''' Os dispositivos represéntanse en linux como ficheiros, que serán de tipo '''b''' (como os discos duros) se son dispositivos de bloque e '''c''' se son de carácter (como a impresora e o teclado).<br />
* '''Enlaces:''' Os enlaces son ficheiros aparentemente independentes que en realidade acceden ao mesmo elemento do sistema de ficheiros. Podemos distinguir dous tipos de enlaces:<br />
: '''- Enlaces débiles ou simbólicos:''' Un enlace simbólico é un "acceso directo" a outro ficheiro. Ao crear un enlace simbólico créase un novo ficheiro dun tipo especial ('''l''') que como datos ten a ruta do ficheiro de destino. Exemplo de creación de enlace simbólico (comando ln coa opción -s):<br />
<source lang="bash"><br />
$ ls -l<br />
total 0<br />
$ touch arquivo<br />
$ ls -l<br />
total 0<br />
-rw-r--r-- 1 root root 0 sep 21 20:20 arquivo<br />
$ ln -s arquivo arquivo-simbolico<br />
$ ls -l<br />
total 0<br />
-rw-r--r-- 1 root root 0 sep 21 20:20 arquivo<br />
lrwxrwxrwx 1 root root 7 sep 21 20:20 arquivo-simbolico -> arquivo<br />
</source><br />
:: · Si borramos '''arquivo''' o enlace '''arquivo-simbolico''' non funcionará. <br />
:: · Un enlace simbólico é como un acceso directo en Windows.<br />
: '''- Enlaces fortes ou duros:''' Os enlaces duros son distintas rutas na árbore que apuntan ao mesmo i-nodo. Non aparecen marcados de ningún xeito especial, pero accedamos a un ou a outro en realidade estaremos accedendo ao mesmo ficheiro. Non se permite crear enlaces fortes a directorios. Exemplo de creación de enlace duro (con ln sen o -s):<br />
<source lang="bash"><br />
$ ln arquivo arquivo-forte<br />
$ ls -li<br />
total 0<br />
261743 -rw-r--r-- 2 root root 0 sep 21 20:32 arquivo<br />
261743 -rw-r--r-- 2 root root 0 sep 21 20:32 arquivo-forte<br />
261744 lrwxrwxrwx 1 root root 7 sep 21 20:32 arquivo-simbolico -> arquivo<br />
</source><br />
:: · Os cambios feitos nun arquivo quedarán reflectidos no outro. <br />
:: · Se borramos un arquivo o outro permanecerá.<br />
:: · Pódense crear enlaces simbólicos pero NON duros a directorios.<br />
:: · Os enlaces simbólicos, a diferencia dos duros, '''permiten "traspasar" as fronteiras dos sistemas de arquivos'''. Esto débese a que os enlaces duros "apuntan" ó arquivo orixinal a través do seu i-nodo. O i-nodo é un elemento que só ten sentido dentro dun mesmo sistema de arquivos. Coma os enlaces simbólicos están baseados en arquivos que almacenan a ruta hacia o arquivo apuntando, éstes sí poden "apuntar" a arquivos noutros sistemas de arquivos, como por exemplo un sistema de arquivo en rede, ou un sistema de arquivos noutro dispositivo.<br />
<br />
== find ==<br />
O comando [http://manpages.ubuntu.com/manpages/oneiric/es/man1/find.1.html find] permite a busca de arquivos:<br />
<br />
Parámetros: <br />
<br />
'''-name''' nome (nome do arquivo a buscar).<br />
<br />
'''-type f dir''' (f->arquivos dir->directorios)<br />
<br />
Exemplo: busca arquivos de tamaño superior a 300MB<br />
<source lang="bash"><br />
# Arquivos que teñen un tamaño maior de 300k<br />
$ find / -type f -size +300k<br />
<br />
# Arquivos ou directorios con nome sources.list<br />
$ find / -name sources.list<br />
<br />
# Arquivos ou directorios creados polo usuario patricia <br />
$ find /home -user patricia<br />
<br />
# Arquivos ou directorio con nome que termine en "list"<br />
$ find /etc -name *list<br />
<br />
# Arquivos ou directorios dentro do directorio /tmp modificados fai máis de 60 días:<br />
$ find /tmp -mtime +60<br />
<br />
# Arquivos ou directorios existentes no teu directorio home que foron modificados nas últimas 24 horas.<br />
$ find $HOME -mtime 0<br />
<br />
# Arquivos ou directorios dentro do directorio de traballo que teñen de permisos exactamente igual a rw-rw-r--:<br />
$ find . -perm 664<br />
<br />
# Arquivos ou directorios dentro do directorio de traballo que teñen de permisos rw-rw-r--, como mínimo:<br />
$ find . -perm -664<br />
<br />
# Arquivos ou directorios dentro do directorio de traballo que teñen de permisos usuario=rw- ou/e grupo=rw- ou/e outros=r--, como mínimo:<br />
$ find . -perm /664<br />
<br />
# Arquivos ou directorios dentro do directorio de traballo creados polo usuario con UID 1000:<br />
$ find . -uid 1000<br />
<br />
# Arquivos ou directorios dentro do directorio de traballo creados por un usuario do grupo con GID 1000:<br />
$ find . -gid 1000<br />
<br />
</source><br />
<br />
== locate ==<br />
Permítenos localizar un arquivo no arbol de directorios.<br />
<source lang="bash"><br />
$ locate resolv.conf<br />
/etc/resolv.conf<br />
/etc/resolvconf/resolv.conf.d<br />
/etc/resolvconf/resolv.conf.d/base<br />
/etc/resolvconf/resolv.conf.d/head<br />
/etc/resolvconf/resolv.conf.d/original<br />
/usr/share/man/man5/resolv.conf.5.gz<br />
<br />
# Para buscar os arquivos que se chamen exactamente "resolv.conf"<br />
$ locate -b '\resolv.conf'<br />
/etc/resolv.conf<br />
<br />
# Para actualizar os arquivos recentemente indexados <br />
# antes de buscar, primeiro, empregar o comando:<br />
$ updatedb<br />
</source><br />
<br />
== which ==<br />
O comando [http://manpages.ubuntu.com/manpages/precise/en/man1/which.1.html which] devolve a ruta dos ficheiros executables dun comando dado. Esta busca a fai sobre os directorios que están especificados na variable '''PATH'''.<br />
<br />
En caso de non atopalo retornase unha mensaxe de erro especificando que o comando non foi atopado.<br />
<br />
Para saber os directorios contidos en '''PATH''' débese escribir na consola:<br />
<br />
<source lang="bash"><br />
$ echo $PATH<br />
/usr/local/bin:/usr/bin:/bin:/usr/games/bin:/usr/local/sbin:/usr/sbin:/sbin<br />
</source><br />
Para configurar o PATH podemos axudarnos do seguinte [http://blockdeubuntu.blogspot.com.es/2009/01/cmo-modificar-la-variable-path.html enlace].<br />
<br />
Vexamos un exemplo da utilización do comando '''which''':<br />
<source lang="bash"><br />
$ which -a ls<br />
/bin/ls<br />
</source><br />
<br />
== cp ==<br />
Copia arquivos e directorios.<br />
O xeito de empregalo sería así: '''cp orixe destino'''<br />
* Copiar un arquivo existente no directorio no que nos atopamos, ''test1'', noutro arquivo chamado ''test2'' e que se garde nese mesmo directorio:<br />
<source lang="bash"><br />
$ cp test1 test2<br />
$ ls -il<br />
total 0<br />
1954793 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test1<br />
1954794 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:39 test2<br />
$<br />
</source><br />
Como se pode ver, o novo arquivo presenta un número de inodo novo.<br />
* Copiar un arquivo existente no directorio no que nos atopamos, ''test1'', noutro directorio chamado ''dir1'' existente no directorio que nos atopamos:<br />
<source lang="bash"><br />
$ cp test1 dir1<br />
$ ls -il dir1<br />
total 0<br />
1954887 -rw-r--r-- 1 usuario usuario 0 Sep 6 09:42 test1<br />
$<br />
</source><br />
O arquivo copiado sería: ''./dir1/test1''.<br />
* Pódese empregar o parámetro '''-p''' para que os parámetros de acceso e os datos de tempos de modificación do arquivo orixinal:<br />
<source lang="bash"><br />
$ cp -p test1 test3<br />
$ ls -il<br />
total 4<br />
1954886 drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:42 dir1/<br />
1954793 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test1<br />
1954794 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:39 test2<br />
1954888 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
$<br />
</source><br />
Os datos de data de modificación dos arquivos orixe (''test1'') e (''test3'') coinciden.<br />
* O parámetro '''-R''' é moi potente pois permítenos copiar '''''recursivamente''''' o contido dun directorio:<br />
<source lang="bash"><br />
$ cp -R dir1 dir2<br />
$ ls -l<br />
total 8<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 6 09:42 dir1/<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 6 09:45 dir2/<br />
-rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test1<br />
-rw-r--r-- 1 usuario usuario 0 Sep 6 09:39 test2<br />
-rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
$<br />
</source><br />
Agora ''dir2'' é unha copia completa de ''dir1''. <br />
* Tamén podemos empregar o carácter '''*''' có comando '''cp''':<br />
<source lang="bash"><br />
$ cp -f test* dir2<br />
$ ls -al dir2<br />
total 12<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 6 10:55 ./<br />
drwxr-xr-x 4 usuario usuario 4096 Sep 6 10:46 ../<br />
-rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test1<br />
-rw-r--r-- 1 usuario usuario 0 Sep 6 10:55 test2<br />
-rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
$<br />
</source><br />
: Có parámetro '''-f''' fórzase a sobreescritura dos arquivos existentes<br />
<br />
* Se precisamos ter dúas copias do mesmo arquivo, pero sen ter fisicamente dous arquivos separados, podemos empregar unha copia física e varias copias virtuais, chamadas '''''links'''''. <br />
:: Existen dous tipos de ''links'' en Linux:<br />
::: - ''Symbolic'', ou ''soft links''.<br />
::: - ''Hard links''.<br />
Un ''hard link'' crea un arquivo separado que contén información sobre o arquivo orixinal e onde está gardado.<br />
<source lang="bash"><br />
$ cp -l test1 test4<br />
$ ls -il<br />
total 16<br />
1954886 drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:42 dir1/<br />
1954889 drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:45 dir2/<br />
1954793 -rw-r--r-- 2 usuario usuario 0 Sep 1 09:51 test1<br />
1954794 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:39 test2<br />
1954888 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
1954793 -rw-r--r-- 2 usuario usuario 0 Sep 1 09:51 test4<br />
$<br />
</source><br />
O parámetro '''-l''' crea un ''hard link'' para o arquivo ''test1'' chamado ''test4''. <br />
Mirando o listado dos arquivos pódese ver que o número de '''inodos''' de ''test1'' e ''test4'' son o mesmo (2), indican que, en realidade, son ambos o mesmo arquivo.<br />
<br />
{{Alerta|¡Ollo!|Non se poden crear ''hard links'' entre arquivos gardados en distintos puntos de montaxe. Nese caso, só se poderán crear ''soft links''.}}<br />
<br />
<br />
* Có parámetro '''-s''' crearanse ''symbolic'', ou ''soft links'':<br />
<source lang="bash"><br />
$ cp -s test1 test5<br />
$ ls -il test*<br />
total 16<br />
1954793 -rw-r--r-- 2 usuario usuario 6 Sep 1 09:51 test1<br />
1954794 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:39 test2<br />
1954888 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
1954793 -rw-r--r-- 2 usuario usuario 6 Sep 1 09:51 test4<br />
1954891 lrwxrwxrwx 1 usuario usuario 5 Sep 1 09:56 test5 -> test1<br />
$<br />
</source><br />
Como se ve o novo arquivo ''test5'' ten un número de '''inodo''' distinto que o arquivo ''test1'', indicando que o sistema Linux o trata como un arquivo distinto. Tamén se ve que o tamaño do arquivo ''test5'' é distinto do tamaño do arquivo ''test1''. Por último, na zona onde aparece o nome do arquivo, aparece a relación existente entre os dous arquivos.<br />
<br />
* Non se permite crear enlaces fortes entre directorios.<br />
<br />
<br />
{{Alerta|INTERÉSACHE|Tamén se pode empregar o comando <strong>ln</strong>. Por defecto o comando <strong>ln</strong> crea <em>hard links</em>. Se ti queres crear un <em>soft link</em> emprega o parámetro <strong>-s</strong>.}}<br />
<br />
== mv ==<br />
El comando '''mv''' emprégase para mover arquivos e directorios:<br />
<source lang="bash"><br />
$ mv test2 test6<br />
$ ls -il test*<br />
1954793 -rw-r--r-- 2 usaurio usaurio 6 Sep 1 09:51 test1<br />
1954888 -rw-r--r-- 1 usaurio usaurio 0 Dec 25 2008 test3<br />
1954793 -rw-r--r-- 2 usaurio usaurio 6 Sep 1 09:51 test4<br />
1954891 lrwxrwxrwx 1 usaurio usaurio 5 Sep 1 09:56 test5 -> test1<br />
1954794 -rw-r--r-- 1 usaurio usaurio 0 Sep 1 09:39 test6<br />
$<br />
</source><br />
Vese que ó mover un arquivo o nome do arquivo cambia pero ten o mesmo inodo e data de creación polo que o arquivo en si non cambiou.<br />
<br />
* O problema é mover un arquivo que teña ''soft links'': <br />
<source lang="bash"><br />
$ mv test1 test8<br />
$ ls -il test*<br />
total 16<br />
1954888 -rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test3<br />
1954793 -rw-r--r-- 2 usuario usuario 6 Sep 1 09:51 test4<br />
1954891 lrwxrwxrwx 1 usuario usuario 5 Sep 1 09:56 test5 -> test1<br />
1954794 -rw-r--r-- 1 usuario usuario 0 Sep 1 09:39 test6<br />
1954793 -rw-r--r-- 2 usuario usuario 6 Sep 1 09:51 test8<br />
[rich@test2 clsc]$ mv test8 test1<br />
</source><br />
O arquivo ''test4'' que ten o ''hard link'' emprega o mesmo número de inodo polo que non hai problema. Pero fixádevos que agora, '''o arquivo ''test5'' apunta agora a un arquivo non válido''' (Por iso aparecerá en vermello). <br />
<br />
* Tamén se pode empregar o comando ''mv'' para mover directorios:<br />
<source lang="bash"><br />
$ mv dir2 dir4<br />
</source><br />
Vese que o único que cambiou é o nome do directorio e nada mais.<br />
<br />
== rm ==<br />
O comando [http://manpages.ubuntu.com/manpages/lucid/man1/rm.1.html rm] nos permite '''borrar''' arquivos. <br />
<br />
* En Linux, borrar denomínase ''remover''. O xeito mais básico de chamar ao comando '''rm''' é o seguinte:<br />
<br />
<source lang="bash"><br />
$ rm -i test6<br />
rm: ¿Borrar o arquivo regular baleiro `test6’? (s/n) s<br />
$ ls -l<br />
total 8<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:42 dir1/<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:45 dir4/<br />
-rw-r--r-- 1 usuario usuario 6 Sep 1 09:51 test3<br />
-rw-r--r-- 2 usuario usuario 0 Dec 25 2008 test4<br />
lrwxrwxrwx 1 usuario usuario 5 Sep 1 09:56 test5 -> test1<br />
-rw-r--r-- 2 usuario usuario 6 Sep 1 09:51 test8<br />
$<br />
</source><br />
<br/><br />
{{Alerta|¡Ollo!|Notar que o comando pregunta se se está seguro de eliminar o arquivo. Hai que darse conta de que no ''bash shell'' non existe ningún tipo de papeleira, polo que se eliminamos un arquivo é para sempre.}}<br />
<br/><br />
<br />
* Agora, eliminaremos un arquivo que ten un '''enlace asociado''', para facer esta práctica primeiramente eliminamos o arquivo ''soft link'' '''test5''' e logo creamos (tal e como se veu antes) un arquivo que conteña a palabra ''Ola'' chamado '''test1''', un ''hard link'' de dito arquivo chamado '''test2''' e un ''soft link'' do arquivo '''test1''' chamado '''test5'''. Unha vez feito isto podemos xa eliminar o arquivo '''test1''' e ver que pasa:<br />
<source lang="bash"><br />
$ rm test1<br />
$ ls -l<br />
total 16<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:42 dir1/<br />
drwxr-xr-x 2 usuario usuario 4096 Sep 1 09:45 dir4/<br />
-rw-r--r-- 1 usuario usuario 0 Dec 25 2008 test2<br />
-rw-r--r-- 1 usuario usuario 6 Sep 1 09:51 test3<br />
lrwxrwxrwx 1 usuario usuario 5 Sep 1 09:56 test5 -> test1<br />
$ cat test2<br />
ola<br />
$ cat test5<br />
cat: test5: Non existe o ficheiro ou directorio<br />
</source><br />
<br />
Removeuse o arquivo '''test1''', que tiña asociado tanto un ''hard link'' có arquivo '''test2''' como un ''soft link'' có arquivo '''test5'''. Como se ve, os dous arquivos seguen aparecendo unha vez eliminado o '''test1'''. Cando se mira o contido do arquivo '''test2''', que era o ''hard link'', este aínda mostra o contido do arquivo. Pero cando se mira o contido do arquivo '''test5''', que era un ''soft link'', vese que está totalmente baleiro.<br />
<br />
== rmdir ==<br />
Borrar directorios pode ser difícil, pero hai un motivo para que isto sexa así. Existen moitas posibilidades de que algo moi malo ocorra cando alguén se pon a borrar directorios. O ''shell bash'' trata de protexernos de catástrofes accidentais todo o posible. O comando básico para eliminar directorios é '''rmdir'''.<br />
<br />
* O seguinte comando elimina o directorio '''dir3''', que é un directorio baleiro:<br />
<source lang="bash"><br />
$ rmdir dir3<br />
$<br />
</source><br />
* Por defecto, o comando '''rmdir''' só elimina directorios baleiros. Se intentamos eliminar o directorio '''test1''', que non é un directorio baleiro, pasará o seguinte: <br />
<source lang="bash"><br />
$ rmdir dir1<br />
rmdir: Non se puido eliminar 'dir1': O directorio non está baleiro<br />
$<br />
</source><br />
Como o directorio '''dir1''' ten un arquivo, o comando '''rmdir''' non o elimina. <br />
* Pódense eliminar directorios baleiros empregando o comando '''rm''', se o intentamos empregar sen parámetros para eliminar o directorio '''dir1''' ocorre o seguinte:<br />
<source lang="bash"><br />
$ rm dir1<br />
rm: non se pode borrar 'dir1': É un directorio<br />
$<br />
</source><br />
* Sen embargo, se realmente queres eliminar un directorio, podes empregar o parámetro '''-r''' para eliminar recursivamente os arquivos do directorio, e o directorio en si:<br />
<source lang="bash"><br />
$ rm -r dir1<br />
$<br />
</source><br />
Se vos pide confirmación para eliminar emprega o parámetro '''-rf'''.<br />
<br />
== stat ==<br />
O comando ''stat'' nos da unha completa información dun arquivo no sistema de arquivos:<br />
Para facer o seguinte exemplo crearemos un arquivo ('''test10''')de texto con varias liñas escritas alternadas con liñas en branco.<br />
Logo executaremos o seguinte comando:<br />
<source lang="bash"><br />
$ stat test10<br />
File: test10<br />
Size: 40 Blocks: 8 IO Block: 4096 arquivo regular<br />
Device: 801h/2049d Inode: 347187 Links: 1<br />
Access: (0644/-rw-r--r--) Uid: ( 1000/usuario) Gid: ( 1000/ usuario)<br />
Acess: 2008-11-05 23:21:01.000000000 +0100<br />
Modify: 2008-11-05 23:21:01.000000000 +0100<br />
Change: 2008-11-05 23:21:01.000000000 +0100<br />
$<br />
</source><br />
<br />
== file ==<br />
O comando ''file'' permítenos coñecer de que tipo é un arquivo determinado. Distingue entre tres tipos distintos:<br />
* '''Arquivos de texto:''' Arquivos que conteñen caracteres imprimibles.<br />
* '''Arquivos executables:''' Arquivos que se poden executar no sistema.<br />
* '''Arquivos de datos:''' Arquivos que conteñen caracteres binarios non imprimibles, pero que non se poden executar no sistema.<br />
<source lang="bash"><br />
$ file test10<br />
test10: ASCII text<br />
$<br />
</source><br />
<br />
== cat ==<br />
O comando ''cat'' nos permite ver os datos existentes no interior dun arquivo de texto:<br />
<source lang="bash"><br />
$ cat test10<br />
ola<br />
<br />
IES San Clemente<br />
<br />
apuntes de linux<br />
$<br />
</source><br />
Este comando ten varios parámetros interesantes:<br />
<br />
* O comando '''-n''' fai que se mostren o número das liñas nos arquivos de texto:<br />
<source lang="bash"><br />
$ cat -n test10<br />
1 ola<br />
2<br />
3 IES San Clemente<br />
4<br />
5 apuntes de linux<br />
$<br />
</source><br />
<br />
* Se queremos que numere só as liñas que teñen texto empregarase o parámetro '''-b''':<br />
<source lang="bash"><br />
$ cat -b test10<br />
1 ola<br />
<br />
2 IES San Clemente<br />
<br />
3 apuntes de linux<br />
$<br />
</source><br />
Se o arquivo é moi longo o comando mostrará todo o contido sen parar, para resolver este "problema" tense o comando ''more''.<br />
<br />
== more==<br />
El comando [http://linuxcommand.org/man_pages/more1.html more] saca por pantalla o contido dos arquivos de texto, pero para despois de mostrar cada páxina. <br />
<br />
O comando ''more'' permite un movemento moi rudimentario ao traveso do arquivo de texto. Para ter mais liberdade de movementos e mais opcións o mellor é empregar o comando ''less''.<br />
<br />
== less ==<br />
Este comando é, simplemente, unha versión avanzada do comando ''more'' ('''''less is more'''''). <br />
<br />
O comando ''less'' nos permite avanzar e retroceder ao longo do arquivo de texto.<br />
<br />
O comando ''less'' tamén ten a propiedade de ser capaz de mostrar o contido dun arquivo antes de que o sistema termine de leelo... esta característica non a ten nin ''more'' nin ''cat''. Polo demais, tamén se comporta como ''more'' no sentido de que, por defecto, mostra os arquivos de páxina en páxina.<br />
<br />
Fixarse que o comando ''less'' nos da información adicional, como pode ser o número total de liñas existente no arquivo, e o rango de liñas mostrado por pantalla. <br />
<br />
O comando ''less'' soporta moitas opcións á hora da execución como as flechas de arriba e abaixo, avance e retroceso de páxina,... (para mais información o mellor é acudir á axuda).<br />
<br />
== tail ==<br />
O comando ''tail'' nos devolve o último grupo de liñas do arquivo. Por defecto mostra as últimas 10 liñas, pero pódese cambiar isto empregando parámetros ('''-n nºdeliñas''').<br />
<br />
* '''Seguimento de arquivos: '''<br />
::: ''tail'' ten unha opción especial, '''-f''' (do inglés ''follow'', seguir), que permite facer seguimento a un arquivo. En lugar de mostrar as últimas liñas e terminar, ''tail'' mostrará as últimas liñas e seguirá lendo do archivo; conforme se lle engadan novas liñas, ''tail'' as imprimirá. Esta función é particularmente útil para arquivos de rexistro.<br />
<br />
* Para pechar ''tail'' cando estea facendo seguimento, chega con interrumpilo con Ctrl+C.<br />
<br />
== head ==<br />
Este comando mostra, por defecto, as 10 primeiras liñas do arquivo que se pase como parámetro.<br />
<br />
== e2fsck ==<br />
e2fsck é empregado para chequear un sistema de arquivos ext2.<br />
<br />
Exemplo:<br />
<source lang="bash"><br />
umount /<br />
e2fsck /dev/...<br />
</source></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Aspectos_avanzados_de_Permisos&diff=67073Aspectos avanzados de Permisos2020-03-20T11:03:12Z<p>Javierfp: /* ACL (Access Control List) */</p>
<hr />
<div>== Permisos por defecto ==<br />
<br />
Cuando se crea un archivo o directorio de un usuario en Linux se le asignan unos permisos por defecto. <br />
Para los directorios, los permisos de base son 0777 (rwxrwxrwx) y para los archivos son 0666 (rw-rw-rw).<br />
<br />
Existe un comando para visualizar y controlar esta asignación de permisos, El comando '''umask'''. Su sintaxis es:<br />
<br />
'''umask [-S] [máscara]'''<br />
<br />
El -S indica que la salida del comando será simbólica<br />
La máscara '''indica aquellos permisos que se restarán del total.''' Es decir, es una representación complementaria a la asignación<br />
<br />
umask sin parámetros muestra la máscara de permisos del usuario<br />
<br />
'''Ejemplos:'''<br />
<br />
<source lang=bash>umask</source><br />
<br />
Muestra la máscara de permisos por defecto del usuario en formato complementario octal<br />
<br />
<source lang=bash>umask -S</source><br />
<br />
Muestra la máscara de permisos por defecto en notación simbólica<br />
<br />
<source lang=bash>umask 022</source><br />
<br />
El umask por defecto 0022 se utiliza para los usuarios regulares. Con esta máscara, los permisos predeterminados de los directorios son 755 , esto es, rwx para propietario, rx para grupo, rx para otros y para los archivos 644, esto es, rw para propietario, r para grupo, r para otros.<br />
<br />
La definición de la máscara para los usuarios del sistema suele realizarse con la directiva '''UMASK''' el archivo '''/etc/login.defs''' y éste es utilizado por el módulo '''PAM (Plugable Authentication Module) pam_umask.so'''.<br />
<br />
Además de los bits de permisos clásicos (rwx) existen otros 3 "especiales" que se utilizan para otros fines. Veámoslos:<br />
<br />
== Sticky bit == <br />
<br />
Es un permiso que solo afecta a directorio y protege de borrados los contenidos del mismo cuando éste es compartido. Es decir, cuando hay permisos de escritura (w) para todos los usuarios que lo comparten pero queremos '''evitar que alguno de los usuarios no propietarios del directorio puedan borrar su contenido'''. En los listados, con el comando ls, por ejemplo haciendo un ls -ld <directorio>, se puede ver al final de la máscara de permisos como una "t". Un ejemplo clásico del uso de este bit es en el directorio /tmp, que suele estar compartido pero con sticky bit activado.<br />
<br />
== Setuid bit ==<br />
<br />
Este es un permiso especial que se aplica a archivos ejecutables. Cuando se ejecuta un programa, archivo ejecutable, se utiliza la identidad del usuario que lo invoca. Por ejemplo el usuario pepe tiene permiso para ejecutar el comando passwd, como podemos ver si hacemos un ls en el directorio /usr/bin donde se ubica ese comando:<br />
<br />
<source lang=bash><br />
-rwsr-xr-x 1 root root 42824 sep 13 00:29 passwd<br />
</source><br />
<br />
vemos que el permiso "x" está activado para todos. Sin embargo en el lugar en el que debiera aparecer la "x" del propietario aparece una "s", indicando que el bit setuid está activado. El significado de ésto es que cuando se ejecute el archivo se hará en nombre y con los permisos de su propietario, en este caso root. Por lo tanto, aunque pepe invoque a passwd éste se ejecutará con usuario root. ¿Y porqué se hace esto así?. Pues porque hay ciertos programas que, independientemente de quién los invoce, necesitan permisos específicos. En el caso de passwd recordad que se utilizaba para cambiar la contraseña de los usuarios del Sistema. Esto requería escribir en el archivo de contraseñas /etc/shadow y, como sabemos, a ese archivo solo tiene acceso root en modo escritura. Por este motivo necesitamos que el bit setuid esté activado en passwd.<br />
<br />
'''NOTA''': Por cuestiones de seguridad algunas distribuciones de Linux desactivan el comportamiento '''setuid''' en scripts de shell. Se conocen varios tipos de ataques de infiltración de código malicioso utilizando este mecanismo en scripts de shell. Por este motivo el comportamiento setuid está deshabilitado en scripts. En el siguiente comentario, extraído de un foro (http://unix.stackexchange.com/questions/364/allow-setuid-on-shell-scripts) se menciona este comportamiento:<br />
<br />
<source lang=bash><br />
Setuid shebang<br />
<br />
There is a race condition inherent to the way shebang (*!) is typically implemented:<br />
<br />
The kernel opens the executable, and finds that it starts with *!.<br />
The kernel closes the executable and opens the interpreter instead.<br />
The kernel inserts the path to the script to the argument list (as argv[1]), and executes the interpreter.<br />
<br />
If setuid scripts are allowed with this implementation, an attacker can invoke an arbitrary script by creating a symbolic<br />
link to an existing setuid script, executing it, and arranging to change the link after the kernel has performed step 1<br />
and before the interpreter gets around to opening its first argument. For this reason, most unices ignore the setuid bit<br />
when they detect a shebang.<br />
</source><br />
<br />
== Setguid bit ==<br />
<br />
Éste es un permiso análogo al anterior con la diferencia de que, en este caso, el programa se ejecuta con los permisos del grupo del propietario del archivo. En caso de que setguid esté activado veremos una s en lugar de una x en la máscara de permisos del segundo grupo de letras rwx (que afectan al grupo del propietario)<br />
<br />
Se pueden activar todos, uno, o ninguno de estos bits setuid y setguid.<br />
<br />
== Establecimiento de los bits de Permisos Especiales ==<br />
<br />
Se puede hacer de 2 formas:<br />
<br />
''' Mediante un cuarto dígito hexadecimal en la máscara de permisos con valores:<br />
'''1000''': Para sticky<br />
'''2000''': Para setuid<br />
'''4000''': Para seguid<br />
<br />
No tiene sentido especificar más de un bit especial por los siguientes motivos:<br />
* Sticky bit solo aplica a directorios<br />
* Setuid bit y Seguid bit se aplican a archivos ejecutables, pero no tiene sentido definir ambos bits, pues sería especificar dos identidades de ejecución diferentes. Por tanto o bien, se ejecuta como propietario, o como miembro del grupo propietario<br />
<br />
Ejemplo:<br />
<br />
<source lang=bash><br />
chmod 1766 /home/usuario/compartido<br />
</source><br />
<br />
Añadiría el bit sticky al directorio /home/usuario/compartido que a su vez tiene máscara de permisos 766 para u(sers)g(roup)o(thers)<br />
<br />
''' En la forma relativa de especificar permisos (mediante letras):'''<br />
* '''t''': Indica sticky<br />
* '''s''': Indica setuid o setguid en función de dónde se ponga la s<br />
<br />
Ejemplo:<br />
<br />
<source lang=bash>chmod u+s /home/usuario/miscript</source><br />
<br />
Si hacemos un <br />
<source lang=bash>ls -la /home/usuario/miscript</source><br />
<br />
veríamos en la máscara de permisos, con umask 022, lo siguiente:<br />
<br />
'''rwsr-xr-x'''<br />
<br />
Ejemplo:<br />
<br />
<source lang=bash>chmod g+s /home/usuario/miscript</source><br />
<br />
Si hacemos un<br />
<source lang=bash>ls -la /home/usuario/miscript</source><br />
<br />
veríamos en la máscara de permisos, con umask 022, lo siguiente:<br />
<br />
'''rwxr-sr-x'''<br />
<br />
Añadirían por tanto los bits setuid y seguid el archivo ejecutable /home/usuario/miscript. Notad que no tiene sentido especificar simultáneamente ámbos.<br />
<br />
== Atributos. Comandos chattr y lsattr ==<br />
<br />
=== lsattr ===<br />
<br />
Comando que permite listar los atributos de archivos y directorios establecidos mediante el comadno '''chattr'''. Ejemplo:<br />
<br />
<source lang=bash><br />
lsattr dir<br />
</source><br />
<br />
Muestra los atributos de los contenidos del directorio dir<br />
<br />
=== chattr ===<br />
<br />
Este comando permite cambiar los atributos de archivos y directorios de un sistema de archivos ext2/ext3/ext4. Solo root puede invocar a este comando<br />
<br />
La sintaxis es:<br />
<br />
'''chattr [opciones] [modo] ficheros'''<br />
<br />
Las opciones son:<br />
<source lang=bash><br />
-R Recursivamente. <br />
-V Muestra una salida detallada<br />
</source><br />
<br />
Los modos, similares en su uso a chmod:<br />
<source lang=bash><br />
+ se usa para añadir atributos <br />
- se usa para quitar atributos<br />
= se usa para especificar los atributos<br />
</source><br />
<br />
<br />
Algunos de esos atributos son: <br />
<br />
* '''A''' evita que se modifique el campo atime al acceder a un fichero. <br />
* '''a''' sólo permite abrir el fichero para añadir datos. <br />
* '''c''' el fichero se guarda automáticamente comprimido por el kernel. <br />
* '''D''' cuando un directorio es modificado, los cambios son escritos síncronamente. <br />
* '''d''' excluye al fichero para ser respaldado por dump. <br />
* '''i''' impide modificar, eliminar, renombrar el fichero y también enlazarlo, es decir lo hace de solo lectura. <br />
* '''s''' al borrar un fichero con este atributo,sus bloques son rellenados con ceros. <br />
* '''S''' cuando un fichero es modificado,los cambios son escritos síncronamente. <br />
* '''u''' cuando un fichero es eliminado,su contenido es guardado. <br />
<br />
<br />
Ejemplo:<br />
<br />
<source lang=bash><br />
chattr -R +c /home/user/doc<br />
</source><br />
<br />
De modo recursivo establece el atributo c (guardar comprimido) del archivo correspondiente<br />
<br />
<source lang=bash><br />
chattr +i test.txt<br />
</source><br />
<br />
Hace de solo lectura el archivo test.txt<br />
<br />
== ACL (Access Control List) ==<br />
<br />
Los sistemas de archivos Linux más modernos, como ext2, ext3 y ext4, permiten la definición de '''ACL''', listas de control de acceso, para regular los permisos de acceso a directorios y archivos. Con la definición de ACL pueden ampliarse las posibilidades de definición de permisos del sistema estándar '''rwx ugo''' y ampliarla a grupos y usuarios fuera de los roles habituales de '''u (user) g (group) y o (others)'''.<br />
<br />
Para poder habilitar las ACL es preciso instalar el paquete correspondiente. Ejecutamos como root, o con sudo:<br />
<br />
<source lang=bash><br />
apt install -y acl<br />
</source><br />
<br />
El sistema de archivos al que se van a aplicar las ACL tiene que ser montado con la opción correspondiente en /etc/fstab, en autofs, o bien mediante un comando de montaje manual. A continuación se ve una entrada en '''/etc/fstab''' a modo de ejemplo:<br />
<br />
<source lang=bash><br />
UUID=07aebd28-24e3-cf19-e37d-1af9a23a45d4 /home ext4 defaults,acl 0 2<br />
</source><br />
<br />
=== Listar ACL de un directorio ===<br />
<br />
Usamos el comando '''getfacl'''<br />
<br />
Supongamos que tenemos en nuestros sistema un directorio '''/comun/ciclos/SMR1/MME''' cuyo resultado a la hora de invocar el comando '''getacl''', según el comando:<br />
<br />
<source lang=bash><br />
getfacl /comun/ciclos/SMR1/MME<br />
</source><br />
<br />
muestra una salida como la siguiente:<br />
<br />
<source lang=bash><br />
# file: .<br />
# owner: javier<br />
# group: profes<br />
user::rwx<br />
group::r-x<br />
group:profes:rwx<br />
group:smr1:r-x<br />
mask::rwx<br />
other::r-x<br />
default:user::rwx<br />
default:group::r-x<br />
default:group:profes:rwx<br />
default:mask::rwx<br />
default:other::r-x<br />
</source><br />
<br />
En esta lista puede verse<br />
* el '''propietario''' del directorio<br />
* el '''grupo propietario''' y los '''otros'''<br />
* los permisos correspondientes a ambos, y también los correspondientes a otros grupos de usuarios que se han añadido a la ACL.<br />
** En este caso, el grupo profes tiene permisos rwx<br />
** el grupo smr1 permisos r-x.<br />
* El parámetro '''mask''' indican los permisos más restrictivos aplicados, es decir, independientemente de lo establecido en la ACL, el valor de mask marcará el máximo permiso utilizable. La directiva mask no afecta a los permisos de user ni other.<br />
* Las entradas '''default''' se aplican únicamente a directorios y afectan a los archivos contenidos dentro del directorio. Están relacionados con la herencia de permisos dentro de los directorios. Según el ejemplo anterior, la entrada para el grupo smr1, es decir los permisos r-x, no serán heredados para los contenidos del directorio, al no estar establecida la directiva default correspondiente.<br />
<br />
'''NOTA''': Para comprobar que en un directorio están activadas las '''ACL''' veremos en la salida de un '''ls -la''' el signo + al final de la línea de los permisos<br />
<br />
=== Gestionar ACLs ===<br />
<br />
Del mismo modo que, para obtener los ACL de un directorio, utilizamos '''getfacl''', para establecer las ACL utilizaremos el comando '''setfacl'''. Con el comando '''setfacl''' se modificarán las ACLs ya aplicadas. Veamos como añadir grupos a la ACL. Ejecutamos (si es necesario como root, o con sudo)<br />
<br />
<source lang=bash><br />
setfacl -m g:green:rwx /var/www/<br />
setfacl -m g:blue:rwx /var/www<br />
</source><br />
<br />
Estamos añadiendo los grupos '''green y blue a la ACL el directorio /var/www''', a estos se le aplicarán los permisos definidos en la propia línea de definición de la ACL. La opción -R aplicará la ACL recursivamente dentro del directorio.<br />
<br />
En el siguiente ejemplo vemos como eliminar un grupo de la ACL:<br />
<br />
<source lang=bash><br />
setfacl -x g:green /var/www<br />
</source><br />
<br />
También es posible transferir ACLs de un directorio a otro, o a través de un archivo de texto. Veamos algún ejemplo:<br />
<br />
<source lang=bash><br />
echo "g:green:rwx" > acl<br />
setfacl -M acl /home/midir<br />
</source><br />
<br />
Escribe la ACL en el archivo acl y luego lo vuelca mediante el comando setacl en el directorio correspondiente<br />
<br />
<source lang=bash><br />
getfacl dir1 | setfacl -b -n -M - dir2<br />
</source><br />
<br />
Recupera ACLs del directorio dir1 y las establece para el directorio dir2<br />
<br />
<source lang=bash><br />
getfacl -a dir1 | setfacl -d -M- dir2<br />
</source><br />
<br />
Copia las ACL de dir1 en la ACL por defecto de dir2<br />
<br />
== Referencias ==<br />
<br />
'''ACL en Linux'''<br />
<br />
https://manuais.iessanclemente.net/index.php/Permisos_e_listas_de_control_de_acceso:_ACLs,_Eiciel<br />
<br />
https://help.ubuntu.com/community/FilePermissionsACLs<br />
<br />
[[Comandos básicos de xestión e administración en linux|Volver]]<br />
<br />
JavierFP 11:31 09 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Instalaci%C3%B3n_e_Compilaci%C3%B3n_de_software&diff=66786Instalación e Compilación de software2020-01-16T09:31:52Z<p>Javierfp: /* Ejemplo: Incorporar un repositorio con clave GPG */</p>
<hr />
<div>== Instalación de software en GNU/Linux ==<br />
<br />
La instalación y mantenimiento de versiones del software de un sistema operativo es uno de los aspectos fundamentales de la administración de un sistema informático.<br />
En GNU/Linux existen una gran cantidad de herramientas disponibles para este cometido, desde interfaces gráficas, hasta herramientas de línea de comandos. Como siempre, el utilizar la linea de comandos, constituye un entorno más flexible y estándar que las herramientas basadas en GUI.<br />
<br />
Existen varias herramientas y comandos para gestionar la instalación de programas en entornos Linux. Dependiendo del tipo de distribución Linux de que se trate encontramos diferencias a la hora de gestionar el software del Sistema Operativo.<br />
<br />
El software en los sistemas Linux se organiza en paquetes que incluyen la versión binaria del programa o utilidad. La idea de este esquema es poder descargar el paquete e integrarlo en nuestro sistema del modo más directo posible. Todos los sistemas incluyen algún tipo de registro de orígenes de paquetes (repositorios). La gestión de repositorios es una de las tareas de administración importantes en la administración del software del sistema. Por ejemplo, en Debian y derivados, los repositorios están registrados en el archivo de texto /etc/apt/sources.list y en los archivos dentro del directorio /etc/apt/sources.list.d.<br />
<br />
Por ejemplo, en los sistemas basados en Debian (como Ubuntu) se utiliza el formato de paquetes binarios .deb. Otros sistemas, como RedHat, Fedora o CentOS utilizan formato de paquetes binario .rpm. Antiguamente se gestionaba de modo manual la instalación de paquetes de software en el sistema, sin embargo esta estrategia causaba múltiples problemas cuando había dependencias involucradas, es decir, cuando ese paquete dependía para su funcionamiento de otros paquetes que no estaban instalados en el sistema. Para solucionar este problema se desarrollaron herramientas que gestionan automáticamente las dependencias de los paquetes, de modo que, el usuario simplemente introduce la orden de instalación del paquete correspondiente y los paquetes de los que depende se instalan automáticamente.<br />
<br />
=== Repositorios ===<br />
<br />
Los repositorios son los almacenes de software, comúnmente denominados paquetes, de las distribuciones Linux. Los repositorios son accesibles públicamente a través de protocolos estándar como http, ftp o https. Utilizando repositorios eliminamos la necesidad de disponer de los binarios de cada una de las utilidades que vamos a necesitar en nuestro sistema. De modo que, si es necesario algún paquete procedemos a instalarlo directamente descargándolo desde el repositorio y ejecutando un script de instalación. Este proceso está automatizado a través de herramientas como las que veremos más adelante.<br />
<br />
Nuestro sistema GNU/Linux, en función de su tipo, utilizará un formato de paquete determinado, siendo los más habituales deb y rpm. En el caso de Debian y derivados se utiliza paquetería deb. Para descargar e instalar la versión binario de un paquete, en formato deb, o rpm, podríamos descargarlo e instalarlo directamente. Sin embargo es común que se produzcan conflictos relacionados con las dependencias, es decir, el conjunto de paquetes necesarios para que el que queremos instalar pueda funcionar. Para evitar los problemas derivados de este hecho se utilizan herramientas que gestionan automáticamente estas dependencias.<br />
<br />
La lista de repositorios, como vimos en el apartado anterior, se definen en el archivo '''/etc/apt/sources.list''' y dentro del directorio '''/etc/apt/sources.list.d'''. Es importante disponer el menos de una lista mínima de repositorios de la distribución que estemos utilizando.<br />
Repositorios mínimos para Debian 9 (stretch)<br />
<br />
En '''/etc/apt/sources.list''' deberíamos tener al menos<br />
<br />
<pre><br />
#Repositorios relacionados con las actualizaciones de seguridad<br />
deb http://security.debian.org/debian-security stretch/updates main contrib<br />
deb-src http://security.debian.org/debian-security stretch/updates main contrib<br />
<br />
#Repositorios de paquetería Debian<br />
deb http://deb.debian.org/debian/ stretch-updates main contrib<br />
deb http://deb.debian.org/debian/ stretch main contrib<br />
<br />
#Repositorios de versiones de código fuente de los paquetes<br />
deb-src http://deb.debian.org/debian/ stretch-updates main contrib<br />
deb-src http://deb.debian.org/debian/ stretch main contrib<br />
</pre><br />
<br />
Cada una de las líneas anteriores consta de<br />
<br />
* '''Formato''': en este caso paquetes deb<br />
* '''URL''' de localización del repositorio<br />
* '''Versión''' de la distribución: en este caso stretch<br />
* '''Ramas''': dentro de las cuales tenemos<br />
** '''main''': rama principal de paquetes de la distribución. Contiene el 90% de los paquetes de la distribución. La totalidad de estos paquetes son libres y cumplen con los 10 principios de la Debian Free software Guidelines.<br />
** '''contrib''': rama de paquetes de colaboradores de la distribución. Contiene software que también cumple con los principios de la Debian Free software Guidelines, pero que precisa de software o paquetes no libres para su compilación y/o ejecución.<br />
** '''non-free''': rama de paquetes de código privativo asociados a la distribución. Incluye paquetes privativos que obviamente no cumplen con las directrices de la Debian Free software Guidelines.<br />
<br />
Una vez definidos los repositorios tendremos que actualizar nuestra caché local de paquetes, consistente en el nombre del paquete, la URL del repositorio en el que se encuentra, y la versión del mismo. Para ello usaremos alguna de las herramientas que se explicarán a continuación.<br />
<br />
==== Repositorios https ====<br />
<br />
Es posible utilizar repositorios https en los archivos de registro de los mismos, como /etc/apt/sources.list. Para ello previamente debemos instalar un paquete que nos permita conectarnos a repositorios que utilizan este protocolo seguro<br />
<br />
<pre>apt install apt-transport-https</pre><br />
<br />
Estos repositorios requerirán procedimiento de autenticación y por tanto deberemos disponer las claves públicas correspondientes para poder utilizarlos<br />
<br />
==== Claves GPG de autenticación en repositorios ====<br />
<br />
Algunos repositorios, http o https, necesitan de acreditar su identidad para poder descargar paquetes desde ellos. Este es un mecanismo de seguridad que evita ataques de suplantación de identidad del repositorio. De este modo, cada vez que nos conectemos al repositorio tendremos la garantía de que su identidad es legítima. Para eso necesitamos disponer de la correspondiente clave pública del repositorio. En caso de no disponer de la clave obtendremos un error como el siguiente a la hora de ejecutar comando apt<br />
<br />
<pre><br />
W: Error de GPG: https://dl.ring.cx/ring-nightly/ubuntu_18.04 ring InRelease: Las firmas siguientes no se pudieron verificar porque su clave pública no está disponible: NO_PUBKEY 64CD5FA175348F84<br />
</pre><br />
<br />
Para solucionarlo incorporamos la clave apt con el comando '''apt-key'''<br />
<br />
===== Ejemplo: Incorporar un repositorio con clave GPG =====<br />
<br />
Vamos a incorporar el repositorio para instalar ring en el directorio de /etc/apt/sources.list.d<br />
<br />
<pre>sh -c "echo 'deb https://dl.ring.cx/ring-nightly/ubuntu_18.04/ ring main' > /etc/apt/sources.list.d/ring-nightly-main.list"</pre><br />
<br />
Si ejecutamos<br />
<br />
<pre>apt update</pre><br />
<br />
Nos encontraremos con el error mencionado. Por tanto, para solucionarlo, vamos a ejecutar el comando para añadir la clave GPG del repositorio<br />
<br />
<pre>apt-key adv --keyserver pgp.mit.edu --recv-keys 64CD5FA175348F84</pre><br />
<br />
El último argumento del comando, a continuación de --recv-keys es el Key ID de la clave buscada. Ahora sí ya podremos utilizar el repositorio y todos los paquetes disponibles en él.<br />
<br />
'''NOTA'''La misma acción podría haberse realizado en varios comandos, primero recibimos del repositorio:<br />
<br />
<pre>gpg --keyserver pgp.mit.edu --recv 64CD5FA175348F84</pre><br />
<br />
a continuación exportamos la clave para añadirla al llavero de apt:<br />
<br />
<pre>gpg --export --armor 64CD5FA175348F84 | apt-key add -</pre><br />
<br />
Si obtenemos un error relacionado con la utilidad dirmngr la instalamos<br />
<br />
<pre>apt install dirmngr<br />
</pre><br />
<br />
=== Repositorios PPA (Personal Package Archive) ===<br />
<br />
Los repositorios PPA son repositorios que permiten a los desarrolladores distribuir software y actualizaciones de forma directa, sin necesidad de que éstos estén disponibles en los repositorios oficiales. Ya sabemos que los repositorios oficiales soportan determinadas versiones de los paquetes que no siempre pueden coincidir con nuestras necesidades.<br />
<br />
Es común que los desarrolladores utilicen estos repositorios para distribuir sus propias versiones y actualizaciones de los paquetes que desarrollan. Para incorporar un repositorio de este tipo a nuestro sistema podemos utilizar el comando '''add-apt-repository''', disponible en el paquete '''software-properties-common'''. En caso de no estar instalado lo hacemos con el siguiente comando<br />
<br />
<pre>apt install software-properties-common</pre><br />
<br />
Una vez instalado ya podremos incorporar estos repositorios al sistema e instalar los paquetes disponibles en ellos<br />
<br />
==== Ejemplo de instalación de paquete a partir de repositorio ppa ====<br />
<br />
Vamos a instalar '''el entorno JDK de Java en su versión 8''', para ello usaremos un repositorio ppa<br />
<br />
<pre><br />
add-apt-repository ppa:webupd8team/java<br />
apt update<br />
apt install oracle-java8-installer<br />
</pre><br />
<br />
Para eliminar un repositorio ppa que no vamos a utilizar o que no nos interesa conservar ejecutamos el mismo comando con la opción --remove:<br />
<br />
<pre>add-apt-repository --remove ppa:webupd8team/java</pre><br />
<br />
=== Comandos apt-get y apt-cache ===<br />
<br />
APT, Advanced Package Tool, es un conjunto de comandos y herramientas utilizados en sistemas Debian para gestionar su software. Algunos comandos útiles:<br />
<br />
Es un comando con varios opciones que determinan su funcionamiento:<br />
<br />
* '''apt-get''' <br />
** '''apt-get update''': Actualiza la caché de paquetes del sistema con las últimas versiones de los repositorios<br />
** '''apt-get upgrade''': Actualiza los paquetes instalados<br />
** '''apt-get dist-upgrade''': Actualiza la totalidad de los paquetes instalados<br />
** '''apt-get install paquete''': Instala el paquete indicado en el sistema. Para instalar una versión concreta de un paquete, podemos utilizar la opción paquete=version<br />
** '''apt-get download paquete''': Descarga el paquete binario en el directorio actual<br />
** '''apt-get check paquete''': Comprueba si hay dependencias rotas<br />
** '''apt-get source paquete''': Descarga fuentes del paquete<br />
** '''apt-get build-dep paquete''': Configura dependencias de compilación para paquetes fuente<br />
** '''apt-get install -f paquete''': Instala el paquete resolviendo dependencias incumplidas<br />
** '''apt-get remove paquete''': Elimina el paquete indicado del sistema<br />
** '''apt-get autoremove''': Elimina paquetes que no son necesarios por ser depedencias no usadas de paquetes ya desintalados<br />
** '''apt-get purge paquete''': Elimina el paquete indicado del sistema y los archivos de configuración asociados<br />
** '''apt-get autoclean''': Elimina los .deb de versiones de paquetes antiguas de la caché en /var/cache/apt/archives<br />
** '''apt-get clean''': Limpia los archivos de paquetes de la caché, antiguos o no<br />
<br />
Es buena práctica, sobretodo antes de un upgrade, o dist-upgrade, el ejecutar un apt-get update para actualizar las cachés de paquetes locales<br />
<br />
* '''apt-cache''': Se utiliza para gestionar la caché de paquetes del sistema<br />
** '''apt-cache search paquete''': Busca información sobre el paquete indicado en la caché del sistema). Pueden utilizarse comodines y expresiones regulares para contextualizar la búsqueda<br />
** '''apt-cache depends paquete''': Muestra las dependencias del paquete indicado<br />
** '''apt-cache stats''': Muestra estadísticas sobre paquetes que hay en la caché<br />
** '''apt-cache unmet''': Muestra dependencias incumplidas de paquetes<br />
** '''apt-cache policy paquete''': Muestra las versiones instaladas y disponibles en el repositorio de un paquete determinado<br />
<br />
=== Comando apt ===<br />
<br />
De uso muy similar, prácticamente idéntico, a apt-get, permite una mayor usabilidad, simplicidad y claridad de información. '''Es la herramienta de gestión de paquetes recomendada por las distribuciones más recientes''' basadas en paquetería debian<br />
<br />
Algunos de los comandos apt más utilizados:<br />
<br />
* '''apt search paquete''': Busca un paquete en la caché, al estilo de apt-cache search<br />
* '''apt list''': Muestra listado de paquetes<br />
* '''apt show paquete''': Muestra información del paquete indicado<br />
* '''apt update''': Actualiza la caché de paquetes del sistema con las últimas versiones de los repositorios<br />
* '''apt upgrade''': Actualiza el sistema instalando y actualizando paquetes<br />
* '''apt full-upgrade''': Actualiza el sistema borrando, instalando y actualizando la totalidad de los paquetes. La diferencia principal con la opción '''upgrade''' es que con '''full-upgrade''' serán eliminados aquellos paquetes que es necesario borrar para completar la actualización, algo que upgrade no hace.<br />
* '''apt install paquete''': Instala el paquete indicado en el sistema<br />
* '''apt remove paquete''': Elimina el paquete indicado del sistema<br />
* '''apt autoremove''': Elimina paquetes que no son necesarios por ser dependencias no usadas de paquetes ya desintalados<br />
* '''apt source paquete''': Descarga fuentes del paquete<br />
* '''apt build-dep paquete''': Configura dependencias de compilación para paquetes fuente<br />
* '''apt purge paquete''': Elimina el paquete indicado del sistema y los archivos de configuración asociados<br />
* '''apt autoclean''': Elimina los .deb de versiones de paquetes antiguas de la caché en '''/var/cache/apt/archives'''<br />
* '''apt clean''': Limpia los archivos de listas de paquetes de la caché, antiguos o no<br />
* '''apt policy paquete''': Muestra la versión instalada y las disponibles en repositorio para un paquete dado<br />
* '''apt edit-sources''': Permita editar las fuentes de repositorios<br />
<br />
=== Instalando con apt ===<br />
<br />
Vamos a ver un pequeño supuesto relacionado con el comando apt a partir de una serie de pasos<br />
<br />
* '''Actualizar la caché de paquetes''': Para ello, una vez que tenemos los repositorios definidos, el primer paso será actualizar la caché local de paquetes de la distribución<br />
<br />
<pre>apt update</pre><br />
<br />
* '''Mostrar un listado de paquetes''': Podemos usar el comando<br />
<br />
<pre>apt list</pre><br />
<br />
el resultado del comando anterior será una lista extensa, podemos restringir los resultados mostrados filtrando con grep<br />
<br />
<pre>apt list | grep mariadb</pre><br />
<br />
mostraría aquellos paquetes que contienen el texto '''mariadb''' en su nombre o descripción<br />
<br />
* '''Mostrar información del paquete build-essential''': Ejecutamos para ello<br />
<br />
<pre>apt show build-essential</pre><br />
<br />
* '''Actualización completa de los paquetes del sistema''': Usaremos para ello el comando '''apt full-upgrade''', sin embargo para evitar realizar la actualización de modo efectivo lo vamos a ejecutar de modo simulado, con la opción '''-s''', la cual nos mostrará simplemente los paquetes que se actualizarán y el tamaño de la descarga<br />
<br />
<pre>apt full-upgrade -s</pre><br />
<br />
* '''Buscar paquetes relacionados con nginx''': Ejecutando<br />
<br />
<pre>apt search nginx</pre><br />
<br />
* '''Por último vamos a instalar el paquete software-properties-common'''<br />
<br />
<pre>apt install -y software-properties-common</pre><br />
<br />
=== Herramienta Aptitude ===<br />
<br />
Interfaz de gestión de paquetes muy funcional y cómoda, al estilo de apt-get, pero más coherente. Comandos:<br />
<br />
* '''aptitude''': Al ejecutarlo sin argumentos muestra una interfaz para buscar, navegar, instalar, actualizar y realizar otras tareas de administración de paquetes.<br />
* '''aptitude install paquete''': Instala software en tu sistema, junto con las dependencias necesarias.<br />
* '''aptitude remove paquete''': Elimina paquetes junto con las dependencias que queden huérfanas.<br />
* '''aptitude purge paquete''': Elimina paquetes y dependencias huérfanas junto con los ficheros de configuración.<br />
* '''aptitude search paquete''': Busca paquetes en las listas de paquetes locales de apt.<br />
* '''aptitude update''': Actualiza las listas de paquetes locales.<br />
* '''aptitude safe-upgrade''': Actualiza los paquetes disponibles de modo seguro, sin borrar ninguno de los existentes<br />
* '''aptitude full-upgrade''': Actualiza los paquetes disponibles de modo seguro, borra si es necesario algún paquete existente para actualizar otro<br />
* '''aptitude clean''': Elimina los ficheros que fué necesario descargar para instalar software en tu sistema.<br />
* '''aptitude show paquete''': Muestra detalles acerca del paquete nombrado.<br />
* '''aptitude autoclean''': Elimina los paquetes deb obsoletos.<br />
* '''aptitude hold paquete''': Fuerza a que un paquete permanezca en su versión actual, y no se actualice.<br />
<br />
Con la opción -s, al invocar alguno de los comandos anteriores se ejecuta la acción pero sin descargar el paquete y modificar el sistema, solo simula la acción<br />
<br />
=== Comando dpkg ===<br />
<br />
Este comando se utiliza para gestionar directamente los paquetes .deb. A diferencia de apt-get no gestiona automáticamente las dependencias.<br />
<br />
Para instalar un paquete en Debian o Ubuntu con este comando utilizamos la sintaxis:<br />
<br />
'''dpkg -i paquete.deb'''<br />
<br />
Para borrar un paquete podemos utilizar la opción -r, con la sintaxis:<br />
<br />
'''dpkg -r paquete'''<br />
<br />
La opción --purge elimina también todos los archivos de configuración asociados al paquete.Veamos un ejemplo:<br />
<br />
Borrado de toda la información de configuración de paquetes eliminados<br />
<br />
<pre>dpkg -l | grep '^rc' | awk '{print $2}' | xargs dpkg --purge</pre><br />
<br />
Para lanzar las opciones de configuración de un paquete que ya ha sido instalado podemos ejecutar:<br />
<br />
'''dpkg-reconfigure paquete'''<br />
<br />
== Parámetrización del Kernel y Compilación de Software en GNU/Linux ==<br />
<br />
=== Parámetros del kernel ===<br />
<br />
Es posible modificar ciertos variables de parámetros del kernel que alterarán el comportamiento del sistema. Para ello debemos editar alguno de los siguientes componentes<br />
<br />
* Archivo '''/etc/sysctl.conf''': Algunas variables, relacionadas con IPv4 e IPv6 se establecen directamente en este archivo de texto. Cada una está perfectamente definida y comentada en el archivo<br />
* '''Directorio /etc/sysctl.d''': Otras variables pueden ser configuradas dentro de los archivos de este directorio, los cuales contienen variables de kernel para distintos aspectos<br />
<br />
Utilizando el comando '''sysctl''' se permite visualizar información y configurar los parámetros de tiempo de ejecución del kernel, para ello especificaremos distintos valores de variables del kernel mediante la sintaxis '''variable=valor'''<br />
<br />
<pre>sysctl -w kernel.hostname=miequipo</pre><br />
<br />
La opción -w (write) especifica la modificación (escritura) de la correspondiente variable.<br />
<br />
Para ver un listado con variables y valores usamos la opción -a<br />
<br />
<pre>sysctl -a</pre><br />
<br />
Para cargar en sysctl los valores de variables definidos en sysctl.conf usamos la opción -p<br />
<br />
<pre>sysctl -p</pre><br />
<br />
Los parámetros que se pueden modificar se encuentran en /proc/sys, dentro de este directorio encontramos los siguientes: abi, debug, dev, fs, kernel, net, vm, dentro de los cuales tenemos archivos y directorios que estructuran las distintas variables en función de su contexto.<br />
<br />
== Compilación de software ==<br />
<br />
Para descargar archivos de Internet mediante línea de comandos, por ejemplo para descargar las fuentes de un programa que queremos compilar o instalar existe un comando, '''wget''', que permite descargar archivos de servidores HTTP o FTP<br />
<br />
<pre><br />
wget ftp://gnjilux.cc.fer.hr/welcome.msg<br />
wget http://fly.cc.fer.hr/welcome.msg<br />
</pre><br />
<br />
Hay varios opciones soportadas pero en o esencial descarga el archivo apuntado por la URL pasada como parámetro<br />
<br />
=== Compilación desde las fuentes ===<br />
<br />
En ocasiones necesitaremos construir los programas directamente desde el código fuente (recordad que Linux es software libre). En general será más habitual encontrar un binario adecuado para la distribución Linux que estemos utilizando, en especial para distribuciones comunes, como Ubuntu, Debian, OpenSuse, etc.<br />
<br />
Aún así a veces, por la rareza del propio software a instalar, o por la versión en concreto, o simplemente por cuestiones de querer optimizar el software para nuestra plataforma y sistema en concreto, se requiere realizar el proceso de compilación desde las fuentes para su posterior instalación.<br />
<br />
Previamente deberemos de disponer de todas las herramientas necesarias para la compilación de programas. Consistentes básicamente en un compilador de C (programa gcc, g++) y librerías. Con el siguiente comando instalamos un meta-paquete (que contiene otros paquetes) que instalará en el sistema todo lo necesario para realizar el proceso de compilación<br />
<br />
<pre>apt install build-essential</pre><br />
<br />
Los pasos a dar son los siguientes:<br />
<br />
* '''Descarga de los fuentes''': Habitualmente en formato tar.gz, tar.zip, tar.bz2. Usando wget y la URL al archivo podemos descargarnos el tar.bz2 o tar.gz<br />
* '''Descomprimir las fuentes''' con el comando tar<br />
<br />
<pre>tar -xzvf nombre_del_programa.tar.gz</pre><br />
<br />
(Para archivos .bz2 en lugar de la opción z usaremos la opción j).<br />
<br />
Leer el archivo '''README''' dentro del directorio resultado del proceso de descompresión anterior. '''Leer el archivo README (como su nombre indica) es muy importante''', pues no siempre el proceso de configuración y compilación que veremos a continuación se realiza del mismo modo<br />
<br />
* '''Comprobar si hay dependencias''' que el programa necesite:<br />
<br />
<pre>apt build-dep nombre_del_programa</pre><br />
<br />
* '''Ejecutar ./configure''' para preparar las fuentes para nuestra plataforma:<br />
<br />
<pre>./configure</pre><br />
<br />
En la llamada al ./configure anterior pueden pasarse múltiples opciones de configuración, previos a la compilación, que personalizan el comportamiento del proceso de creación del binario durante el posterior proceso de compilación. Una de las opciones más habituales es '''--prefix''' el cual permite establecer el directorio en el que se va a ubicar el binario correspondiente.<br />
<br />
* '''Generar el binario (compilación)'''<br />
<br />
<pre>make</pre><br />
<br />
* '''Instalar'''<br />
<br />
<pre>make install</pre><br />
<br />
...para desinstalar:<br />
<br />
<pre>make uninstall</pre><br />
<br />
=== Utilidad checkinstall ===<br />
<br />
Cuando se compila software desde las fuentes puede ser complicado borrarlo con posterioridad a la instalación. En ocasiones los programadores crea un target '''make uninstall''', pero éste no se encuentra disponible en muchos casos. Para poder hacer una instalación limpia, y que más tarde pueda ser eliminada, podemos utilizar el paquete '''checkinstall'''.<br />
<br />
Este paquete consiste en una utilidad de línea de comandos checkinstall, que deberá ser '''invocada tras el ./configure'''. Automáticamente invoca a make y realiza un inventario de todas las modificaciones que se realizarán en el sistema. Por lo general crea un paquete .deb o .rpm desde el cual se realiza la instalación. De este modo el paquete puede ser desinstalado fácilmanente mediante, por ejemplo, un comando dpkg -r <paquete>.<br />
<br />
Su instalación es muy sencilla<br />
<br />
<pre>apt install checkinstall</pre><br />
<br />
=== Ejemplo. Compilación de nginx ===<br />
<br />
Vamos a instalar el paquete nginx desde utilizando para ello el código fuente.<br />
<br />
* En primer lugar instalamos las dependencias necesarias para poder compilar nginx desde las fuentes<br />
<br />
<pre>apt build-dep nginx</pre><br />
<br />
* Ahora descargamos las fuentes de nginx en el directorio /tmp<br />
<br />
<pre><br />
cd /tmp<br />
apt source nginx<br />
</pre><br />
<br />
* A continuación instalamos nginx desde las fuentes. En primer lugar nos movemos al directorio /tmp/nginx-<version>, donde version indica la versión de las fuentes que hemos descargado.<br />
<br />
<pre><br />
cd nginx-1.10.3<br />
./configure<br />
make<br />
make install<br />
</pre><br />
<br />
Tras lo cual ya dispondremos del servidor instalado. Arrancamos el servicio<br />
<br />
<pre>/usr/local/nginx/sbin/nginx</pre><br />
<br />
Y ya podremos acceder al servicio en el puerto 80 para comprobar que efectivamente funciona<br />
<br />
== Instalando módulos dinámicos ==<br />
<br />
La herramienta '''dkms''' (dynamic kernel module support) permite instalar módulos que se vinculan al kernel durante el arranque del sistema. Permite vincular módulos al kernel que residen en árboles de código fuente diferentes al árbol de códigos fuente del kernel. Además, este aspecto se gestiona de manera automática en cada arranque. Si se detecta un cambio en el kernel el módulo se compila para la versión correspondiente del mismo.<br />
<br />
Tradicionalmente los módulos del kernel se añadían de forma estática al mismo, de modo que, cuando se actualizaba éste a una nueva versión, los módulos desplegados de este modo dejaban de funcionar en el nuevo kernel.<br />
<br />
Con dkms vinculamos los módulos al kernel de modo dinámico. Cuando el kernel se actualice los correspondientes módulos serán compilados e integrados en el nuevo kernel. Esta herramienta resulta muy útil para conseguir que nuestros dispositivos funcionen independientemente de la versión del kernel que estemos ejecutando.<br />
<br />
Muchos de los módulos disponibles para Linux incorporan versiones para dkms.<br />
<br />
=== Comandos útiles de dkms ===<br />
<br />
* '''dkms status: '''muestra el estado de los módulos gestionados con dkms<br />
<br />
* '''dkms install: '''permite instalar un módulo con dkms<br />
<br />
* '''dkms autoinstall: '''actualiza todos los módulos a la nueva versión del kernel<br />
<br />
* '''dkms remove: '''elimina un módulo de dkms<br />
<br />
=== Ejemplo de instalación de módulo fuente con dkms ===<br />
<br />
Primero instalamos la herramienta dkms<br />
<br />
<pre><br />
apt install -y linux-headers-`cat /proc/version | awk '{print $3}'`<br />
apt install -y dkms<br />
</pre><br />
<br />
Antes, como vemos debemos instalar el paquete '''linux-headers''' para la versión correspodiente de nuestro kernel<br />
<br />
Ahora descargamos los fuentes del módulo en el directorio tmp<br />
<pre><br />
cd /tmp<br />
wget https://sourceforge.net/projects/e1000/files/ixgbe%20stable/5.2.4/ixgbe-5.2.4.tar.gz https://sourceforge.net/projects/e1000/files/ixgbe%20stable/5.2.4/ixgbe-5.2.4.tar.gz<br />
</pre><br />
<br />
'''NOTA''': Si la utilidad wget no está instalada en nuestro sistema, podemos instalarla con<br />
<br />
<pre>apt install wget</pre><br />
<br />
Extraemos los contenidos del tar.gz y los colocamos en el directorio de fuentes del kernel<br />
<br />
<pre><br />
tar xzf ixgbe-5.2.4.tar.gz -C /usr/local/src<br />
mv /usr/local/src/ixgbe-5.2.4/src /usr/src/ixgbe-5.2.4<br />
</pre><br />
<br />
Creamos el archivo de configuración dkms<br />
<br />
<pre>vi /usr/src/ixgbe-5.2.4/dkms.conf</pre><br />
<br />
Añadimos lo siguiente a ese archivo<br />
<br />
<pre><br />
PACKAGE_NAME="ixgbe"<br />
PACKAGE_VERSION="5.2.4"<br />
BUILT_MODULE_NAME[0]="ixgbe"<br />
DEST_MODULE_LOCATION[0]="/kernel/drivers/net/ethernet/intel/ixgbe/"<br />
AUTOINSTALL="yes"<br />
</pre><br />
<br />
Añadimos a continuación el módulo a dkms<br />
<br />
<pre>dkms add -m ixgbe -v 5.2.4</pre><br />
<br />
Construímos el módulo con soporte dkms<br />
<br />
<pre>dkms build -m ixgbe -v 5.2.4</pre><br />
<br />
Y por último instalamos el módulo para nuestra versión del kernel<br />
<br />
<pre>dkms install -m ixgbe -v 5.2.4</pre><br />
<br />
Para comprobar que efectivamente el módulo se ha instalado correctamente<br />
<br />
<pre>dkms status</pre><br />
<br />
Deberíamos ver una salida como<br />
<br />
<pre>ixgbe, 5.2.4, 4.9.0-3-amd64, x86_64: installed</pre><br />
<br />
A partir de ahora, cada vez que se actualice la versión del kernel, o se invoque a dkms con la opción autoinstall, se compilará de nuevo el módulo y se vinculará automáticamente con el kernel correspondiente.<br />
<br />
[[Linux|Volver]]<br />
<br />
JavierFP 16:58 22 nov 2017 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Instalaci%C3%B3n_sobre_RAID_e_LVM&diff=66063Instalación sobre RAID e LVM2019-11-28T07:46:08Z<p>Javierfp: /* Primer procedimiento. Utilizando el comando dd */</p>
<hr />
<div>==Prerequisitos==<br />
<br />
* Conocer el concepto '''RAID''', y concretamente el nivel RAID 1 (Mirroring)<br />
* Conocer el concepto '''LVM''' (Logical Volumen Manager)<br />
* Disponer de una imagen .iso de Debian9<br />
* Sistema de virtualización de escritorio: VirtualBox, KVM, HyperV, etc<br />
<br />
== Instalación sobre RAID 1 por software ==<br />
<br />
Creamos una máquina virtual con '''dos discos virtuales del mismo tamaño'''. Conectamos un medio de instalación a la unidad de CDROM e iniciamos el proceso de instalación.<br />
<br />
=== 1.- Creación del dispositivo RAID software ===<br />
<br />
Desde el instalador, '''en el apartado de Particionado''', seguimos los siguientes pasos<br />
<br />
* Particionado en modo Manual<br />
* Crear una tabla de particiones en cada disco<br />
* Definir cada partición como volumen físico para RAID<br />
* Configurar RAID por software<br />
* Crear un dispositivo MD<br />
* RAID1<br />
* Seleccionar dispositivos para RAID (cada una de las 2 particiones)<br />
* Terminar<br />
<br />
A la conclusión de estos pasos dispondremos de un dispositivo '''/dev/md0''' de tipo RAID1<br />
<br />
=== 2.- Particionado del dispositivo RAID software ===<br />
<br />
Seguimos en el '''instalador'''<br />
<br />
* Definir la partición #1 del dispositivo RAID1 /dev/md0<br />
* Utilizar como ext4<br />
* Montar en /<br />
* Se ha terminado de definir la partición<br />
<br />
=== 3.- Finalizar el particionado y escribir los cambios en el disco ===<br />
<br />
Tras lo cual terminamos la instalación del sistema.<br />
<br />
=== 4.- Chequeos ===<br />
<br />
Comprobación de los dispositivos: <br />
<br />
<pre><br />
mdadm --detail --scan<br />
cat /proc/mdstat<br />
</pre><br />
<br />
Ver los datos del dispositivo (para un dispositivo dado): <br />
<br />
<pre>mdam --detail /dev/md0</pre><br />
<br />
== Instalación sobre RAID1 con LVM ==<br />
<br />
Desde el '''instalador''' de Debian, en el '''apartado de Particionado''', editar el dispositivo creado en el punto 2 del procedimiento anterior, /dev/md0, para que la partición que alberga sea utilizada como volumen físico para LVM. A continuación ejecutar los pasos:<br />
<br />
* Configurar el Gestor de Volúmenes Lógicos LVM<br />
* Mantener distribución<br />
* Crear grupo de volúmenes con nombre '''VG1'''<br />
* Añadir el dispositivo '''/dev/md0'''<br />
* Crear un volumen lógico en '''VG1''' de nombre '''VL1'''<br />
* Terminar<br />
* Volvemos al punto 3 del apartado anterior para definir la partición de instalación en el volumen lógico creado '''VL1'''<br />
<br />
Una vez completados los pasos anteriores la distribución de particionado debería de ser la siguiente<br />
<br />
[[Archivo:particionado.png]]<br />
<br />
Tras terminar la instalación y reiniciar podremos comprobar como, efectivamente, el Sistema de Archivos ahora subyace sobre el Volumen Lógico '''VL1'''<br />
<br />
<pre>mount -l | grep ext4</pre><br />
<br />
muestra<br />
<br />
<pre>/dev/mapper/VG1-VL1 on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)</pre><br />
<br />
== Duplicación del GRUB para poder arrancar desde cualquiera de los 2 discos ==<br />
<br />
Al acabar la instalación anterior nos había pedido instalar el gestor de arranque GRUB en uno de los discos. GRUB necesita un soporte de dispositivo de bajo nivel, y no puede ser instalado en el dispositivo RAID1 /dev/md0.<br />
<br />
El dispositivo /dev/md0 está compuesto por las dos particiones:<br />
<br />
* '''sda1''': primera partición del primer disco<br />
* '''sdb1''': primera partición del segundo disco<br />
<br />
Este dispositivo no tiene nada que ver con GRUB, ya que solo “conoce” particiones en los discos, es decir, el arranque queda relegado a los discos. Por tanto, para poder arrancar el sistema, en un contexto de alta disponibilidad, desde cualquiera de los discos, deberíamos de duplicar GRUB en el disco en el que éste no se ha incluído en el proceso de instalación.<br />
<br />
Puede ocurrir que el disco en el que se ha instalado GRUB falle y por tanto, ya que estamos usando un RAID1 en el sistema de archivos, sería deseable también poder arrancar desde el otro dispositivo. El problema es que si no tenemos GRUB instalado en el segundo disco no podremos arrancar desde él.<br />
<br />
Vamos a duplicar GRUB en el segundo disco para que, en caso de que falle el primero, poder arrancar desde él.<br />
<br />
=== Primer procedimiento. Utilizando el comando dd ===<br />
<br />
Supongamos que el dispositivo en el que instalamos GRUB es /dev/sda, es decir, el primer disco duro SATA. Ejecutamos<br />
<br />
<pre>dd if=/dev/sda of=/dev/sdb count=100</pre><br />
<br />
Con el comando anterior copiamos los primeros bloques, incluyendo al MBR, del primer disco duro /dev/sda en el segundo, /dev/sdb. Copiando un único bloque, con count=1, no funcionaría porque los metadatos que necesita GRUB se extienden más allá del primer bloque físico del disco.<br />
<br />
A continuación desconectamos el primer disco duro, /dev/sda, de la máquina virtual y arrancamos. El resultado debería de ser el arranque normal del sistema.<br />
<br />
Tras el arranque el dispositivo /dev/md0 debe de encontrarse en modo fallo, pues uno de los discos que alberga una de las particiones que le sirven de soporte no está presente.<br />
<br />
Podemos ver ese estado ejecutando<br />
<br />
<pre>mdadm --detail /dev/md0</pre><br />
<br />
<br />
Observando la salida de este comando podremos ver como, efectivamente, el RAID se encuentra en estado degradado.<br />
<br />
Para solucionarlo, apagamos la máquina y volvemos a conectar el primer disco a la máquina virtual. Arrancamos y veremos que al ejecutar el comando anterior<br />
<br />
<pre>mdadm --detail /dev/md0</pre><br />
<br />
la salida del comando indica que el array sigue estando degradado. Esto se debe a que mdadm ha detectado anteriormente la ausencia del disco /dev/sda y ha eliminado su partición del dispositivo /dev/md0, de modo que muestra el dispositivo como “removed”.<br />
<br />
A continuación ejecutamos:<br />
<br />
<pre>mdadm --manage /dev/md0 --add /dev/sda1</pre><br />
<br />
Este comando añade de nuevo la partición del dispositivo en conflicto al RAID. El proceso tarda un tiempo, pues mdadm vuelve a copiar los datos de la partición “sana”, en la nueva partición. Al terminar el estado del RAID vuelve a ser consistente.<br />
<br />
=== Segundo procedimiento. Utilizando grub-install ===<br />
<br />
Otro modo de proceder para poder arrancar con GRUB desde el segundo disco, /dev/sdb, es instalarlo directamente en ese disco, para ello ejecutamos<br />
<br />
<pre><br />
grub-install /dev/sdb<br />
update-grub /dev/sdb<br />
</pre><br />
<br />
El resto del procedimiento es análogo al apartado anterior.<br />
<br />
== Simulación de un fallo en el RAID ==<br />
<br />
Para probar el comportamiento de mdadm ante fallo de uno de los dispositivos dentro del array podemos utilizar el propio comando mdadm.<br />
<br />
A continuación vamos a poner como faulty, “en fallo”, el primer dispositivo, correspondiente a la primera partición del primer disco duro del array<br />
<br />
<pre>mdadm --manage /dev/md0 --fail /dev/sda1</pre><br />
<br />
Con el comando:<br />
<br />
<pre>mdadm --detail /dev/md0</pre><br />
<br />
veremos las propiedades del volumen RAID1 y como, efectivamente, uno de los dispositivos aparece en estado de fallo y solo tenemos activo al dispositivo /dev/sdb1<br />
<br />
A continuación reiniciamos la máquina<br />
<br />
<pre>reboot</pre><br />
<br />
En el siguiente arranque usará el dispositivo activo, es decir el segundo disco duro. Si éste dispone de GRUB, podremos arrancar sin problema.<br />
<br />
Tras el reinicio, podremos añadir de nuevo el dispositivo que pusimos faulty al array<br />
<br />
<pre>mdadm --manage /dev/md0 --add /dev/sda1</pre><br />
<br />
Tardará un tiempo en completar el proceso de regeneración del array, el cual podremos monitorizar con el comando anterior<br />
<br />
<pre>mdadm --detail /dev/md0</pre><br />
<br />
== Ampliación del Grupo de Volúmenes con otro dispositivo RAID1 ==<br />
<br />
Vamos a hacer uso de las características de LVM para aumentar el espacio de almacenamiento disponible para el sistema de archivos. Para ello realizaremos los siguientes pasos:<br />
<br />
* Creación de un nuevo dispositivo RAID1 sobre dos discos duros virtuales<br />
* Particionado de los discos y creación del dispositivo RAID1 con mdadm<br />
* Creación del PV (Volumen Físico) LVM para el dispositivo anterior<br />
* Asignación del PV al VG (Grupo de Volúmenes) LVM utilizado en la instalación<br />
* Ampliación del VL (Volumen Lógico) LVM utilizado en la instalación con el nuevo PV<br />
<br />
=== Esquema de la configuración ===<br />
<br />
En el siguiente gráfico vemos la distribución de los componentes:<br />
<br />
* /'''dev/md0 y /dev/md1''' son los dispositivos RAID por software que serán utilizados como volúmenes físicos, es decir, como recursos de almacenamiento. Estos dispositivos, a su vez, contienen dos dispositivos físicos en modo “espejo”, RAID1, para disponer de seguridad física basada en redundancia de datos.<br />
* '''VG1''' es el '''Grupo de Volúmenes''' LVM, dentro del cual se asignarán los '''PV''' (V'''olúmenes Físicos''') LVM. Por último, dentro del VG también se define el '''VL1''', '''Volumen Lógico''', que conlleva asociados PV. Mediante el concepto de VL independizamos los recursos de almacenamiento, en este caso los dispositivos RAID1, del Sistema de Archivos desplegado sobre el VL. Los términos Grupo de Volúmenes (VG), Volumen Físico (PV) y Volumen Lógico (LV) son términos asociados a LVM.<br />
<br />
[[Archivo:raid_lvm.png]]<br />
<br />
=== Conexión de discos virtuales para el RAID1 ===<br />
<br />
En el siguiente procedimiento vamos a añadir otro dispositivo RAID1 por software como Volumen Físico asociado al Volumen Lógico VL1, dentro del grupo de volúmenes VG1 LVM configurado en nuestra instalación.<br />
<br />
Añadimos a la máquina virtual '''otros 2 discos virtuales''' del mismo tamaño.<br />
<br />
Al arrancar la máquina ejecutamos lsblk para ver los nuevos dispositivos conectados<br />
<br />
<pre>lsblk</pre><br />
<br />
Como vemos en la salida hay dos nuevos dispositivos sdc y sdd, correspondientes a los dos nuevos discos virtuales conectados.<br />
<br />
=== Particionado de los discos ===<br />
<br />
Usamos el comando fdisk<br />
<br />
<pre>fdisk /dev/sdc</pre><br />
<br />
Creamos una partición primaria que abarque todo el espacio, y con la opción t de fdisk, establecemos el tipo a “fd”, el cual hace referencia a “Linux raid autodetect”<br />
<br />
Repetimos los pasos para el otro disco<br />
<br />
<pre>fdisk /dev/sdd</pre><br />
<br />
=== Creación del nuevo dispositivo RAID1 ===<br />
<br />
A continuación vamos a crear el nuevo dispositivo RAID1 que abarcará la partición creada en los dos dispositivos anteriores<br />
<br />
<pre>mdadm --create /dev/md1 --level=1 --raid-devices=2 /dev/sdc1 /dev/sdd1</pre><br />
<br />
Este nuevo dispositivo llevará por nombre '''md1''' y su archivo de dispositivo será /dev/md1<br />
<br />
=== Creación del Volumen Físico LVM sobre el dispositivo RAID1 ===<br />
<br />
Ejecutamos<br />
<br />
<pre>pvcreate /dev/md1</pre><br />
<br />
Con el comando anterior creamos un volumen físico sobre el dispositivo RAID1 creado anteriormente. De este modo disponemos de un nuevo dispositivo de almacenamiento asignable al Grupo de volúmenes LVM '''VG1''' que creamos durante la configuración del instalador con LVM, el cual será asignado al Volumen Lógico '''VL1''', de modo que extenderemos el tamaño de éste, y por tanto la disponibilidad de almacenamiento del Sistema de Archivos desplegado sobre VL1.<br />
<br />
=== Extensión del Grupo de Volúmenes VG1 con el Volumen Físico ===<br />
<br />
Para ello ejecutamos<br />
<br />
<pre>vgextend VG1 /dev/md1</pre><br />
<br />
con el comando<br />
<br />
<pre>vgdisplay</pre><br />
<br />
podremos ver los detalles de configuración de VG1.<br />
<br />
El comando<br />
<br />
<pre>pvscan</pre><br />
<br />
también resultará de utilidad para comprobar la disponibilidad de Volúmenes Fisicos. En este caso la salida será del tipo<br />
<br />
<pre><br />
PV /dev/md0 VG VG1 lvm2 [7,99 GiB / 0 free]<br />
PV /dev/md1 VG VG1 lvm2 [7,99 GiB / 7,99 GiB free]<br />
Total: 2 [15,98 GiB] / in use: 2 [15,98 GiB] / in no VG: 0 [0 ]<br />
</pre><br />
<br />
=== Extensión del Volumen Lógico VL1 con el nuevo Volumen Físico ===<br />
<br />
Ejecutando <br />
<br />
<pre>lvdisplay</pre><br />
<br />
Vemos los detalles de configuración de los volúmenes lógicos LVM. En este caso nos mostrará la información relativa al único definido VL1<br />
<br />
<pre><br />
--- Logical volume ---<br />
LV Path /dev/VG1/VL1<br />
LV Name VL1<br />
VG Name VG1<br />
LV UUID qpZEHB-bn0S-IGAV-9d0D-G06Y-ch5E-qamBxH<br />
LV Write Access read/write<br />
LV Creation host, time debian, 2017-11-16 16:16:38 +0100<br />
LV Status available<br />
<nowiki># open </nowiki> 1<br />
LV Size '''7,99 GiB'''<br />
Current LE 2046<br />
Segments 1<br />
Allocation inherit<br />
Read ahead sectors auto<br />
- currently set to 256<br />
Block device 253:0<br />
</pre><br />
<br />
Ahora vamos a añadir a VL1 el Volumen Fisico /dev/md1<br />
<br />
<pre>lvextend /dev/VG1/VL1 /dev/md1</pre><br />
<br />
Si ejecutamos de nuevo:<br />
<br />
<pre>lvdisplay</pre><br />
<br />
<pre><br />
--- Logical volume ---<br />
LV Path /dev/VG1/VL1<br />
LV Name VL1<br />
VG Name VG1<br />
LV UUID qpZEHB-bn0S-IGAV-9d0D-G06Y-ch5E-qamBxH<br />
LV Write Access read/write<br />
LV Creation host, time debian, 2017-11-16 16:16:38 +0100<br />
LV Status available<br />
<nowiki># open </nowiki> 1<br />
LV Size '''15,98 GiB'''<br />
Current LE 4092<br />
Segments 2<br />
Allocation inherit<br />
Read ahead sectors auto<br />
- currently set to 256<br />
Block device 253:0<br />
</pre><br />
<br />
Vemos como ahora el espacio LV size el volumen lógico ha aumentado al doble tras haber añadido el Volumen Físico /dev/md1 a VL1<br />
<br />
Por último redimensionamos el espacio disponible para el Sistema de Archivos mediante el comando<br />
<br />
<pre>resize2fs /dev/VG1/VL1</pre><br />
<br />
Comprobamos que efectivamente el espacio disponible para el Sistema de Archivos ha aumentado, para ello ejectuamos<br />
<br />
<pre>df -h</pre><br />
<br />
== Referencias==<br />
<br />
RAID<br />
https://es.wikipedia.org/wiki/RAID<br />
<br />
LVM<br />
https://blog.inittab.org/administracion-sistemas/lvm-para-torpes-i/<br />
<br />
[[Linux|Volver]]<br />
<br />
JavierFP 15:18 18 nov 2017 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Icinga&diff=65893Icinga2019-04-30T15:08:48Z<p>Javierfp: /* Macros y Attributes */</p>
<hr />
<div>== Instalación de Icinga Core ==<br />
<br />
Veremos a continuación los pasos de instalación y puesta en marcha de Icinga2 sobre Debian 9 (stretch)<br />
<br />
=== Actualizamos caché de paquetes ===<br />
<br />
<pre><br />
apt update<br />
</pre><br />
<br />
=== Descarga de clave de repositorio y registro del mismo en la lista de repositorios del sistema ===<br />
<br />
<pre><br />
wget -O - https://packages.icinga.com/icinga.key | apt-key add -<br />
echo 'deb https://packages.icinga.com/debian icinga-stretch main' >/etc/apt/sources.list.d/icinga.list<br />
</pre><br />
<br />
=== Instalación de Icinga Core ===<br />
<br />
<pre><br />
apt install -y apt-transport-https<br />
apt update<br />
apt install -y icinga2<br />
</pre><br />
<br />
=== Instalación de plugins ===<br />
<br />
<pre><br />
apt install -y monitoring-plugins<br />
</pre><br />
<br />
== Instalación de Icingaweb ==<br />
<br />
El proyecto dispone de una interesante interfaz web que permite visualizar la información de monitorización recopilada por Icinga. Vamos a realizar los pasos de instalación necesarios<br />
<br />
=== Instalando icingaweb2 mariadb-server y módulos ido-mysql ===<br />
<br />
<pre><br />
apt install -y icingaweb2 icingacli mariadb-server icinga2-ido-mysql<br />
</pre><br />
<br />
'''Responder “No”''' a las preguntas del asistente de instalación del módulo ido-mysql<br />
<br />
=== Creación de bases de datos ===<br />
<br />
Accedemos a la consola de administración del cliente de mysql<br />
<br />
<pre><br />
mysql -u root<br />
</pre><br />
<br />
Ejecutamos desde el cliente mysql las siguientes sentencias de creación de las bases de datos icingaweb2, para almacenar los usuarios y grupos de icinga, e icingaido en el que se almacenará la información de monitorización. En ambos casos concederemos permisos al usuario icinga de mysql<br />
<br />
<pre><br />
CREATE DATABASE icingaweb2;<br />
GRANT ALL ON icingaweb2.* TO icinga@localhost IDENTIFIED by 'abc123.';<br />
CREATE DATABASE icingaido;<br />
GRANT ALL ON icingaido.* TO icinga@localhost IDENTIFIED by 'abc123.';<br />
</pre><br />
<br />
Una vez ejecutados los comandos de creación de la base de datos anteriores, salimos del cliente mysql con<br />
<br />
<pre><br />
quit<br />
</pre><br />
<br />
Vamos a incorporar el '''schema IDO-Mysql''' en la base de datos icingaido que acabamos de crear. Este schema IDO (Icinga Data Output) será utilizado por Icinga a la hora de escribir en Mysql los datos de monitorización recopilados<br />
<br />
<pre><br />
mysql -u root icingaido < /usr/share/icinga2-ido-mysql/schema/mysql.sql<br />
</pre><br />
<br />
=== Web Setup para Icingaweb ===<br />
<br />
Accedemos a través del navegador web a icingaweb para la realización del setup<br />
<br />
http://IP_ICINGA/icingaweb2/setup<br />
<br />
==== Creación del token ====<br />
<br />
Lo primero que nos pide es un setup token, el cual podremos generar con el comando<br />
<br />
<pre><br />
icingacli setup token create<br />
</pre><br />
<br />
Copiamos el token generado y lo pegamos en la caja de texto del primer paso de configuración del Web Setup.<br />
<br />
Si en el siguiente paso aparece la alerta de que no está definido el '''default.timezone''' de php lo hacemos editando el archivo correspondiente<br />
<br />
==== Configuración del date.timezone de php ====<br />
<br />
<pre><br />
vi /etc/php/7.0/apache2/php.ini<br />
</pre><br />
<br />
Descomentando y estableciendo la directiva<br />
<br />
<pre><br />
date.timezone = Europe/Madrid<br />
</pre><br />
<br />
Tras lo cual reiniciamos apache y ya podremos continuar<br />
<br />
<pre><br />
service apache2 restart<br />
</pre><br />
<br />
==== Usuario admin y password ====<br />
<br />
Establecemos el usuario '''admin y su password'''<br />
<br />
'''user''': admin<br />
'''password''': abc123.<br />
<br />
==== Definición de recurso de bases de datos ====<br />
<br />
'''NOTA''': A la hora de establecer credenciales para MySql, utilizar las creadas anteriormente y para la codificación '''utf8'''<br />
<br />
El primer elemento a configurar es la base de datos en la que se almacenará la '''configuración de usuarios y grupos''' de icinga, introducimos las credenciales para la base de datos '''icingaweb2'''.<br />
<br />
[[Archivo:icinga-db-resource.png|800px]]<br />
<br />
==== Configuración de datos de aplicación ====<br />
<br />
En la sección “'''Application Configuration'''” seleccionamos la opción “File System”<br />
<br />
[[Archivo:icinga-application-config.png|800px]]<br />
<br />
==== Recurso de base de datos de monitorización IDO ====<br />
<br />
A continuación vamos a editar el archivo /etc/icinga2/features-available/ido-mysql.conf para habilitar el módulo IDO de MySql<br />
<br />
<pre><br />
vi /etc/icinga2/features-available/ido-mysql.conf<br />
</pre><br />
<br />
Establecemos los valores según lo indicado en la creación de la base de datos<br />
<br />
<pre><br />
object IdoMysqlConnection "ido-mysql" {<br />
user = "icinga",<br />
password = "abc123.",<br />
host = "localhost",<br />
database = "icingaido"<br />
}<br />
</pre><br />
<br />
Ejecutamos el comando para '''habilitar ido-mysql'''<br />
<br />
<pre><br />
icinga2 feature enable ido-mysql<br />
</pre><br />
<br />
Reiniciamos el servicio de icinga<br />
<br />
<pre><br />
systemctl restart icinga2.service<br />
</pre><br />
<br />
Establecemos el Recurso de bases de datos para la información de monitorización, en este caso usaremos la base de datos '''icingaido''', la cual incorpora el esquema ido-myql<br />
<br />
[[Archivo:icinga-ido-resource.png|800px]]<br />
<br />
En la página '''Command Transport''' seleccionamos Transport Type “'''Local Command File'''”<br />
<br />
Tras lo cual pulsamos '''Finish'''. Si todo va bien deberíamos de ver la siguiente página<br />
<br />
[[Archivo:icinga-congrats.png|800px]]<br />
<br />
Una vez hacemos login en Icinga e introducimos el usuario y contraseña creados durante el proceso de setup (usuario: admin, password: abc123.), veremos el Dashboard de monitorización de IcingaWeb<br />
<br />
[[Archivo:icinga-panel.png|800px]]<br />
<br />
== Principios de monitorización de Icinga ==<br />
<br />
El objetivo principal a la hora de diseñar Icinga fue la modularidad. El concepto de monitorización es muy genérico y dependiente del contexto, por tanto los sistemas que ofrecen soluciones al problema deben de ser muy flexibles, adaptables y abiertos en cuanto a requisitos y funcionalidad.<br />
<br />
La ventaja del diseño modular de Icinga es que satisface los requisitos de flexibilidad y carácter adaptable y abierto. Por el contrario, nos encontramos con un sistema complejo y en algunos aspectos difícil de comprender. Aún así, para casos de uso no complicados, el tiempo de puesta en marcha y el esfuerzo necesario para el despliegue es bastante bajo.<br />
<br />
Vamos a ver algunos de los elementos centrales que constituyen el núcleo del motor de monitorización de Icinga.<br />
<br />
=== Host y Services ===<br />
<br />
Un '''host''' es un equipo que alberga servicios que pueden ser monitorizados. Entre otros atributos se definen comunmente su nombre y dirección o hostname<br />
<br />
Un '''service''' es el elemento fundamental a monitorizar, y que por lo general corresponde con algún servicio en ejecución.<br />
<br />
Veamos algún ejemplo:<br />
<br />
<pre><br />
object Host "my-server1" {<br />
address = "10.0.0.1"<br />
check_command = "hostalive"<br />
}<br />
<br />
object Service "ping4" {<br />
host_name = "my-server1"<br />
check_command = "ping4"<br />
}<br />
<br />
object Service "http" {<br />
host_name = "my-server1"<br />
check_command = "http"<br />
}<br />
</pre><br />
<br />
Vemos''' '''en los ejemplos anteriores:<br />
* Un elemento '''Host,''' dentro del cual se definen los atributos:<br />
** '''address''': la dirección IP o hostname del host<br />
** '''check_command''': identifica el comando de chequeo a efectuar en relación al host, en este caso un hostalive corresponde con un ping<br />
* Dos elementos '''Service''', en los que se definen<br />
** '''host_name''': el nombre del host asociado al service, es decir, el nombre del host que “corre” el service, en este caso el definido anteriormente<br />
** '''check_command''': comando de chequeo para monitorizar el servicio<br />
<br />
Los comandos de chequeo forman parte de los plugins de Icinga, y constituyen el elemento funcional más importante del sistema de monitorización. En el ejemplo anterior encontramos dos ejemplos:<br />
* '''http''': comando del plugin check_http<br />
* '''ping4''': comando perteneciente al plugin check_ping que efectúa un ping IPv4<br />
<br />
'''NOTA'''<br />
<br />
Para determinar las ubicaciones de los plugins podemos visualizar el contenido del archivo '''/etc/icinga2/constants.conf '''donde se definen, entre otras, variables de localización de los directorios de plugins, por defecto estos se ubican en /usr/lib/nagios/plugins<br />
<br />
=== Host Groups y Service Groups ===<br />
<br />
Es posible agrupar conjuntos de hosts mediante la definición de un elemento '''HostGroup'''. Del mismo modo pueden agruparse Servicios utilizando elementos de tipo '''ServiceGroup'''. Veamos algún ejemplo:<br />
<br />
==== extracto del archivo /etc/icinga2/conf.d/groups.conf ====<br />
<br />
<pre><br />
object HostGroup "linux-servers" {<br />
<br />
display_name = "Linux Servers"<br />
<br />
assign where host.vars.os == "Linux"<br />
<br />
}<br />
</pre><br />
<br />
La sintaxis es clara, se define un '''HostGroup''' y se agruparán los hosts utilizando como criterio lo establecido por la directiva '''assign''', que en este caso agrupa todos los Host que tengan establecida la variable '''vars.os''' al valor “Linux”.<br />
<br />
De modo análogo podríamos establecer un HostGroup para los windows-servers<br />
<br />
<pre><br />
object HostGroup "windows-servers" {<br />
<br />
display_name = "Windows Servers"<br />
<br />
assign where host.vars.os == "Windows"<br />
<br />
}<br />
</pre><br />
<br />
A continuación vemos la definición de un objeto '''ServiceGroup'''<br />
<br />
<pre><br />
object ServiceGroup "ping" {<br />
<br />
display_name = "Ping Checks"<br />
<br />
assign where match("ping*", service.name)<br />
<br />
}<br />
</pre><br />
<br />
Este ejemplo es similar, con la salvedad de que se está definiendo un elemento de tipo ServiceGroup, cuya finalidad es agrupar Services que tengan algo en común; en este caso según la directiva '''assign''', se establece que todos los Services que tengan en el valor del atributo '''service.name''' el texto “ping” serán agrupados bajo el ServiceGroup “Ping Checks”<br />
<br />
==== Otros ejemplos ====<br />
<br />
<pre><br />
object HostGroup "web-servers" {<br />
<br />
display_name = "Web Servers"<br />
<br />
assign where host.vars.webserver == true<br />
<br />
}<br />
</pre><br />
<br />
De nuevo resulta claro el tipo de agrupamiento, en este caso todos aquellos Host que tengan establecido a true al atributo '''vars.webserver'''<br />
<br />
Por último definimos un '''HostGroup''' para agrupar los Host que corran un servicio MySQL, estos erán identificados mediante el atributo de Host '''vars.mysql''' establecido a true<br />
<br />
<pre><br />
object HostGroup "mysql-servers" {<br />
<br />
display_name = "MySQL Servers"<br />
<br />
assign where host.vars.mysql == true<br />
<br />
}<br />
</pre><br />
<br />
Vemos en el panel IcingaWeb los correspondientes HostGroup y ServiceGroup<br />
<br />
'''HostGroups'''<br />
<br />
[[Archivo:icinga-hostgroup.png|800px]]<br />
<br />
'''ServiceGroups'''<br />
<br />
[[Archivo:icinga-servicegroups.png|800px]]<br />
<br />
=== Commands ===<br />
<br />
Los '''command''' son los elementos que definen como se realizan los chequeos de monitorización. Existe una directiva definida en los objetos de tipo service, check_command, que define el tipo de chequeo a realizar.<br />
<br />
Hay los siguientes tipos<br />
<br />
==== Check Command ====<br />
<br />
Definen como se efectúan los comandos de chequeo asociados a la monitorización. Básicamente los objetos CheckCommand se definen para pasar parámetros de ejecución a los plugins de monitorización. Veamos un ejemplo<br />
<br />
<pre><br />
object CheckCommand "my-mysql" {<br />
command = [ PluginDir + "/check_mysql" ] //constants.conf -> const PluginDir<br />
<br />
arguments = {<br />
"-H" = "$mysql_host$"<br />
"-u" = {<br />
required = true<br />
value = "$mysql_user$"<br />
}<br />
"-p" = "$mysql_password$"<br />
"-P" = "$mysql_port$"<br />
"-s" = "$mysql_socket$"<br />
"-a" = "$mysql_cert$"<br />
"-d" = "$mysql_database$"<br />
"-k" = "$mysql_key$"<br />
"-C" = "$mysql_ca_cert$"<br />
"-D" = "$mysql_ca_dir$"<br />
"-L" = "$mysql_ciphers$"<br />
"-f" = "$mysql_optfile$"<br />
"-g" = "$mysql_group$"<br />
"-S" = {<br />
set_if = "$mysql_check_slave$"<br />
description = "Check if the slave thread is running properly."<br />
}<br />
"-l" = {<br />
set_if = "$mysql_ssl$"<br />
description = "Use ssl encryption"<br />
}<br />
}<br />
<br />
vars.mysql_check_slave = false<br />
vars.mysql_ssl = false<br />
vars.mysql_host = "$address$"<br />
}<br />
</pre><br />
<br />
En la definición del CheckCommand anterior podemos ver tres tipos de atributos:<br />
* '''command''': indica el plugin invocado por el CheckCommand, utiliza la ruta absoluta establecida a partir del parámetro que define en constants.conf la ruta al directorio de plugins<br />
* '''arguments''': definen los argumentos pasados al plugin, se construyen a partir de los atributos (variables) definidas en los distintos contextos.<br />
* '''custom attributes''': atributos definidos de forma personalizada. Se utiliza con este propósito el attribute '''vars''', donde se pueden almacenar de modo arbitrario valores de información<br />
<br />
<br />
==== Notification Command ====<br />
<br />
Indican como se gestionan las notificaciones asociadas a eventos de notificación, por ejemplo envío de mails, mensaje IRC, etc.<br />
<br />
=== Templates ===<br />
<br />
Los '''templates''' son definiciones utilizadas para englobar parámetros comunes que se pueden aplicar a otros elementos de forma conjunta. De este modo evitamos el definir varias veces los mismos parámetros. Veamos algún ejemplo:<br />
<br />
==== extracto del archivo: /etc/icinga2/conf.d/templates.conf: ====<br />
<br />
<pre><br />
template Service "generic-service" {<br />
<br />
max_check_attempts = 5<br />
<br />
check_interval = 1m<br />
<br />
retry_interval = 30s<br />
<br />
}<br />
</pre><br />
<br />
El template anterior define una plantilla para servicios, estableciendo atributos por defecto compartidos por todos los objetos Service que hagan un import del template. Básicamente establece el tiempo entre chequeos, 1 minuto, el máximo número de reintentos en caso de fallo, 5, y el período de reintento ante fallo, 30 segundos.<br />
<br />
A continuación vemos la definición de un Service que hace uso del template anterior<br />
<br />
==== extracto del archivo: /etc/icinga2/conf.d/services.conf: ====<br />
<br />
<pre><br />
apply Service for (disk => config in host.vars.disks) {<br />
<br />
import "generic-service"<br />
<br />
check_command = "disk"<br />
<br />
vars += config<br />
<br />
}<br />
</pre><br />
<br />
En la definición del cuerpo del '''Service''' vemos la cláusula '''import''' que hace referencia a '''generic-service''', mostrado anteriormente, por tanto todos los atributos de generic-service serán de aplicación en el elemento '''apply. '''Más adelante volveremos sobre este ejemplo.<br />
<br />
=== Macros y Attributes ===<br />
<br />
Los '''atributtes''' se asocian a la definición de los hosts, services, commands, etc., y permiten definir los objetos mediante la especificación de su información esencial. Existen varios scopes o ámbitos de atributos y también la posibilidad de definir '''custom attributes,''' característica muy útil para personalizar el comportamiento de los objetos de Icinga. Por tanto los objetos Icinga serán definidos a partir de sus elementos attribute.<br />
<br />
Por ejemplo:<br />
<br />
<pre><br />
object Host "localhost" {<br />
check_command = "ssh"<br />
vars.ssh_port = 2222<br />
}<br />
</pre><br />
<br />
El extracto anterior muestra la definición de un objeto Host asociado al cual se definen dos attributes el atributo '''check_command''' que establece el comando de chequeo asociado al objeto, en este caso “ssh” indica que se verificará la disponibilidad del servicio ssh<br />
* el '''custom attribute ssh_port''' definido dentro de la variable vars, la cual almacena valores personalizados asociados al objeto, en este caso en el ámbito del objeto Host. El funcionamiento sería el siguiente:<br />
<br />
Al ejecutar el check_command asociado al objeto es necesario pasar una serie de parámetros al mismo. En este caso el comando ssh necesitaría información para el chequeo, básicamente:<br />
* la dirección IP o hostname, '''address''', del host: como no se especifica se toma por defecto la dirección o name del propio Host, en este caso “localhost”<br />
* El '''puerto''': si no se especifica se tomaría por defecto el 22, sin embargo, en este caso hemos definido un atributo, ssh_port, dentro de vars, lo cual permite establecer un custom attribute. Este valor así definido sobreescribiría el valor por defecto, 22, del atributo ssh_port definido en el propio command, de este modo se efectuará el test contra localhost en el puerto 2222.<br />
<br />
Los elementos '''macro''' permiten recuperar información en tiempo real sobre los elementos a monitorizar. Algunos permiten recuperar simplemente variables con información, otros permiten definir comportamientos dinámicos mediante la definición de funciones. Constituyen por tanto elementos de información que se pueden consultar y que serán buscados en los distintos elementos, recuperando la coincidencia más cercana. Es importante consultar la documentación de los plugins para conocer los parámetros y valores por defecto de estos en los command.<br />
<br />
Por ejemplo:<br />
<br />
<pre><br />
vars.ping_address = "$address$"<br />
</pre><br />
<br />
hace uso de la macro $address$ que en este caso será localizada a partir del atributo address del objeto host. Concretamente la línea anterior asigna un custom attribute, dentro de la variable vars, el atributo ping_address, al que se asigna el valor del atributo address del host.<br />
<br />
El orden de evaluación, la primera coincidencia, a la hora de buscar los atributos a los que se refieren las macros son:<br />
* '''User''' object (solo para notificaciones)<br />
* '''Service''' object<br />
* '''Host''' object <br />
* '''Command''' object<br />
* '''Global''' '''custom attributes''' definidos en '''vars'''<br />
<br />
=== Apply Rules ===<br />
<br />
Las '''apply rules''' dotan de una gran potencia a Icinga, al permitir especificar comportamientos de los objetos en función de la verificación de reglas. De este modo se puede realizar una aplicación condicional e iterada sobre elementos del entorno. Simplifican enormemente el trabajo de definición de las políticas de monitorización.<br />
<br />
Veamos un ejemplo:<br />
<br />
==== extracto del archivo: /etc/icinga2/conf.d/services.conf: ====<br />
<br />
<pre><br />
apply Service "ping4" {<br />
import "generic-service"<br />
check_command = "ping4"<br />
assign where host.address<br />
}<br />
</pre><br />
<br />
la cual define una regla que aplica un comando, definido en la directiva '''check_command''' a los elementos de tipo '''Service''' que verifiquen la condición establecida en la directiva '''assign.''' Además se hace uso del template '''generic-service''', cuyos atributos se incluyen mediante la directiva '''import. '''La definición del template generic-service se encuentra en el archivo /etc/icinga2/conf.d templates.conf.<br />
<br />
Volvamos a un ejemplo anterior:<br />
<br />
<pre><br />
apply Service for (disk => config in host.vars.disks) {<br />
import "generic-service"<br />
check_command = "disk"<br />
vars += config<br />
}<br />
</pre><br />
<br />
En este caso usamos la directiva '''apply''' para definir la aplicación de un Service en función de la colección definida en el atributo de '''host''' '''vars.disks''', el cual podrá ser definido en la propia definición del host. En la definición del cuerpo del '''Service''' vemos la cláusula import que hace referencia a '''generic-service''', mostrado anteriormente, por tanto todos los atributos de generic-service serán de aplicación en el elemento '''apply'''. El apply funciona como un bucle for que itera por todos los elementos del array vars.disks del host.<br />
<br />
El elemento anterior aplica un chequeo para cada elemento iterado, recuperando los atributos de cada elemento disk del array vars.disks, en el elemento '''config''', y añadiéndolos a los custom attributes, en vars, de cada Service de chequeo de cada disco.<br />
<br />
<div style="margin-left:0cm;margin-right:0cm;">En resumen, el apply anterior sería algo como “para cada objeto disco definido el la variable vars.disks del host, un array, se realizará un chequeo basado en el comando disk, con los parámetros de chequeo definidos a partir de los attributes de cada elemento disk”.</div><br />
<br />
=== Plugins ===<br />
<br />
Los '''plugins''' son los elementos que definen las herramientas de chequeo, invocadas mediante elementos command, utilizadas a la hora de establecer las políticas de monitorización. El objetivo es que se ejecuten en un entorno en el que sea posible y ágil el definir nuevos elementos de este tipo, así como facilitar una integración sencilla con los elementos de monitorización.<br />
<br />
Cada plugin ofrece una funcionalidad accesible a través de los command asociados. Es posible definir objetos CheckCommand que indiquen la parametrización pasada al command, para ello es importante leer la documentación del plugin, sus comandos asociados, y los parámetros soportados<br />
<br />
En la lista de [[#Referencias|Referencias]] de más abajo encontramos el listado de plugins estándar de Icinga, en esta lista se incluyen plugins para monitorización de:<br />
* Sistemas Windows<br />
* Sistemas Linux<br />
* Sistemas de Gestión de Bases de Datos<br />
* Sistemas de Servicio Web<br />
* Sistemas de Red<br />
* y un largo etc.<br />
<br />
== Entorno de Icinga ==<br />
<br />
Al instalar Icinga se crean varios directorios en los que se almacenan los elementos necesarios para el construir el entorno de monitorización:<br />
<br />
=== Directorio /etc/icinga2 ===<br />
<br />
En este directorio nos encontramos:<br />
* '''icinga2.conf''': archivo de configuración principal de Icinga. Básicamente consta de una serie de directivas “include” que incorporan al entorno los elementos del ecosistema de monitorización<br />
* '''constants.conf''': archivo donde se definen constantes de entorno. Principalmente se definen constantes relacionadas con las rutas de los directorios en los que nos encontramos los plugins de monitorización. Los plugins son el soporte para los commands que definen las acciones de chequeo o monitorización.<br />
* '''conf.d''': Directorio en el que se ubican los archivos con las definiciones de los elementos vistos en el punto anterior: hosts, services, templates, etc.<br />
* '''scripts''': Directorio en el que encontramos scripts de shell invocados desde objetos Command de tipo Notification<br />
<br />
=== Directorio /usr/lib/nagios/plugins ===<br />
<br />
Directorio por defecto de los plugins de Icinga (basado en Nagios). En el nos encontramos ejecutables, binarios o scripts, que implementan una funcionalidad concreta de monitorización. Por lo general tienen nombres del tipo check_xxx autoexplicativos.<br />
<br />
== Ejemplo. Monitorización del Host Icinga ==<br />
<br />
El propio Host en el que corre Icinga está sujeto a la monitorización establecida por defecto. Veamos la definición del propio Host en el archivo '''/etc/icinga2/hosts.conf:'''<br />
<br />
<pre><br />
object Host NodeName {<br />
/* Import the default host template defined in `templates.conf`. */<br />
import "generic-host"<br />
<br />
/* Specify the address attributes for checks e.g. `ssh` or `http`. */<br />
address = "127.0.0.1"<br />
address6 = "::1"<br />
<br />
/* Set custom attribute `os` for hostgroup assignment in `groups.conf`. */<br />
vars.os = "Docker"<br />
<br />
/* Define http vhost attributes for service apply rules in `services.conf`. */<br />
vars.http_vhosts["http"] = {<br />
http_uri = "/"<br />
}<br />
/* Uncomment if you've sucessfully installed Icinga Web 2. */<br />
//vars.http_vhosts["Icinga Web 2"] = {<br />
// http_uri = "/icingaweb2"<br />
//}<br />
<br />
/* Define disks and attributes for service apply rules in `services.conf`. */<br />
vars.disks["disk"] = {<br />
/* No parameters. */<br />
}<br />
vars.disks["disk /"] = {<br />
disk_partitions = "/"<br />
}<br />
<br />
/* Define notification mail attributes for notification apply rules in `notifications.conf`. */<br />
vars.notification["mail"] = {<br />
/* The UserGroup `icingaadmins` is defined in `users.conf`. */<br />
groups = [ "icingaadmins" ]<br />
}<br />
}<br />
</pre><br />
<br />
Se define el elemento Host de nombre "NodeName", el primer elemento en el cuerpo de la definición es la directiva '''import''', que establece que se tomen los atributros del template '''generic-host''', el cual establece básicamente la periodicidad de los chequeos.<br />
<br />
Puede apreciarse a continuación como se definen atributos:<br />
<br />
Algunos sobreescriben atributos específicos del objeto Hosts:<br />
* '''address'''<br />
* '''address6'''<br />
<br />
Otros son atributos específicos (custom attributes) que definen información arbitraria que será utilizada por el sistema de plugins de monitorización. Estos valores se almacenan en vars, en el ejemplo anterior tenemos:<br />
* '''vars.os''': identifica el sistema que corre el Host<br />
* '''vars.http_vhosts''': incorporaría información relevante para monitorización de servicios http de ser el caso<br />
* '''vars.disks''': almacenaría información relativa a los dispositivos de almacenamiento y los puntos de montaje a monitorizar para el Host<br />
* '''vars.notification''': este mapa asociativo permitiría definir información relacionada con la notificación de eventos de monitorización de Icinga<br />
<br />
A continuación inspeccionamos el archivo '''/etc/icinga2/services.conf''', para ver como se hace uso de la información definida en los atributos del ejemplo anterior<br />
<br />
<pre><br />
apply Service "ping4" {<br />
import "generic-service"<br />
<br />
check_command = "ping4"<br />
<br />
assign where host.address<br />
}<br />
<br />
apply Service "ping6" {<br />
import "generic-service"<br />
<br />
check_command = "ping6"<br />
<br />
assign where host.address6<br />
}<br />
<br />
apply Service "ssh" {<br />
import "generic-service"<br />
<br />
check_command = "ssh"<br />
<br />
assign where (host.address || host.address6) && host.vars.os == "Linux"<br />
}<br />
<br />
apply Service for (http_vhost => config in host.vars.http_vhosts) {<br />
import "generic-service"<br />
<br />
check_command = "http"<br />
<br />
vars += config<br />
}<br />
<br />
apply Service for (disk => config in host.vars.disks) {<br />
import "generic-service"<br />
<br />
check_command = "disk"<br />
<br />
vars += config<br />
}<br />
<br />
apply Service "icinga" {<br />
import "generic-service"<br />
<br />
check_command = "icinga"<br />
<br />
assign where host.name == NodeName<br />
}<br />
<br />
apply Service "load" {<br />
import "generic-service"<br />
<br />
check_command = "load"<br />
<br />
/* Used by the ScheduledDowntime apply rule in `downtimes.conf`. */<br />
vars.backup_downtime = "02:00-03:00"<br />
<br />
assign where host.name == NodeName<br />
}<br />
<br />
apply Service "procs" {<br />
import "generic-service"<br />
<br />
check_command = "procs"<br />
<br />
assign where host.name == NodeName<br />
}<br />
<br />
apply Service "swap" {<br />
import "generic-service"<br />
<br />
check_command = "swap"<br />
<br />
assign where host.name == NodeName<br />
}<br />
<br />
apply Service "users" {<br />
import "generic-service"<br />
<br />
check_command = "users"<br />
<br />
assign where host.name == NodeName<br />
}<br />
</pre><br />
<br />
Podemos observar como se definen los Service a partir de los elementos '''apply''' que aplican condiciones en función de la directiva '''assign'''. Cada Service definido se aplicaría solo en caso de que la directiva assign arrojase el valor verdadero.<br />
<br />
Debemos observar como se hace uso extensivo de los atributos del Host, referenciados mediante la sintaxis host.<atributo>, y que establecen las condiciones mencionadas arriba.<br />
<br />
Por ejemplo, el elemento '''apply Service ssh''' solo será aplicado cuando se haya asignado una dirección, address, IPv4 o IPv6, al Host, y éste tenga definida la variable host.vars.os al valor "Linux". A todo Host definido según esas premisas se le aplicará el Service ssh.<br />
<br />
Tenemos otros elementos apply más complejos, como el correspondiente a la monitorización de los dispositivos de almacenamiento:<br />
<br />
<pre><br />
apply Service for (disk => config in host.vars.disks) {<br />
import "generic-service"<br />
<br />
check_command = "disk"<br />
<br />
vars += config<br />
}<br />
</pre><br />
<br />
El cual en su definición recorre, mediante un for, los elementos definidos en el array '''host.vars.disk''', procesando cada uno de los elementos y ejecutando el checkcommand correspondiente, en este caso un comando de chequeo disk, que verifica el estado del dispositivo. Por tanto, para todo elemento del Host definido en ese array se ejecutará el check.<br />
<br />
Por último, vemos también el elemento<br />
<br />
<pre><br />
apply Service "swap" {<br />
import "generic-service"<br />
<br />
check_command = "swap"<br />
<br />
assign where host.name == NodeName<br />
}<br />
</pre><br />
<br />
Que ejecuta un check del espacio de intercambio, swap, del Host, pero en este caso éste solo se aplica en caso de que el '''host.name''' sea "NodeName", es decir, el Host de monitorización.<br />
<br />
== Caso práctico 1. Monitorización simple de servicios ==<br />
<br />
Vamos a ver un sencillo caso de uso en el que monitorizaremos dos servicios:<br />
* Un servicio '''MySQL''' corriendo en otro host con IP '''192.168.0.10'''<br />
* Un servicio '''Nginx''' corriendo en un host con IP '''192.168.0.11'''<br />
<br />
'''Necesitaremos''' por tanto:<br />
* Un host corriendo '''Icinga''' Core y la interfaz Icinga Web<br />
* Un host corriendo un servicio '''mysql''' en el puerto estándar 3306 con IP '''192.168.0.10''' accesible en la misma subred que el nodo Icinga<br />
* Un host corriendo un servicio '''nginx''' en el puerto estándar 80 con IP '''192.168.0.11''' accesible en la misma subred que el nodo Icinga<br />
<br />
Una vez tengamos los 3 sistemas anteriores en funcionamiento procedemos a crear los elementos para la monitorización.<br />
<br />
Para ello, vamos a definir:<br />
* Dos objetos de tipo Host que representen los sistemas en los que corren los servicios<br />
* Dos objetos de tipo Service que representan los servicios en sí<br />
<br />
La implementación pasará por crear el archivo '''mis_servicios.conf''' dentro del directorio '''/etc/icinga2/conf.d<br />
'''<br />
<br />
Dentro de ese archivo tendremos el siguiente contenido<br />
<br />
<pre><br />
object Host "mysqlmi" {<br />
<br />
import "generic-host"<br />
<br />
address = "192.168.0.10"<br />
<br />
vars.mysql = true<br />
<br />
}<br />
</pre><br />
<br />
Este primer elemento define el Host del servicio mysql, los tributos definidos en esta sección incluyen:<br />
* El '''nombre''' del objeto Host, en este caso mysqlmi<br />
* La directiva '''import''' hace uso del template generic-host, en el que se definen los atributos de un Host genérico, como ya hemos visto más arriba<br />
* El atributo '''address''' define la dirección IP, en este caso 192.168.0.10, del Host<br />
* Por último definimos un '''atributo personalizado''' (custom attribute), los cuales como vimos siempre se definen dentro de vars, que será utilizado a la hora de aplicar el correspondiente Servicio de monitorización a los Host etiquetados como “servicios mysql”<br />
<br />
<pre><br />
apply Service "mysql-test" {<br />
<br />
import "generic-service"<br />
<br />
display_name = "MySQL Test"<br />
<br />
check_command = "mysql"<br />
<br />
vars.mysql_database = "mysql"<br />
<br />
vars.mysql_username = "root"<br />
<br />
vars.mysql_password = "abc123."<br />
<br />
assign where host.vars.mysql == true<br />
<br />
}<br />
</pre><br />
<br />
El elemento apply anterior define la aplicación del Service definido en función del atributo '''host.vars.mysql''', es decir, los Hosts etiquetados como tal serán tenidos en cuenta como servicios de ese tipo a los que se aplican las directivas de monitorización indicadas, entre las cuales tenemos:<br />
* La directiva '''import''' que hace uso del template generic-service<br />
* El '''display_name''', que indica el nombre del servicio de monitorización de mysql<br />
* El '''check_command''', que indican el comando de monitorización utilizado para supervisar el servicio mysql, en este caso el comando mysql, definido en el plugin check_mysql<br />
* 3 '''atributos personalizados''', dentro de '''vars''', que serán utilizados como parámetros por el command anterior<br />
* Por último la directiva '''assign''' establece que se aplicará la monitorización en función del valor del atributo '''host.vars.mysql,''' el cual como vimos se estableció en la definición del Host, por tanto solo se aplicará a los Hosts etiquetados con tal atributo<br />
<br />
De forma análoga a lo anterior definimos el objeto Host y el apply Service para un servicio web, en este caso para un servidor nginx:<br />
<br />
<pre><br />
object Host "nginxmi" {<br />
<br />
import "generic-host"<br />
<br />
address = "192.168.0.11" <br />
<br />
vars.webserver = true<br />
<br />
}<br />
</pre><br />
<br />
En este caso el atributo '''vars.webserver''', etiqueta el Host para vincularlo con el apply Service que sigue:<br />
<br />
<pre><br />
apply Service "nginx-test" {<br />
<br />
import "generic-service" <br />
<br />
display_name = "Nginx Test"<br />
<br />
check_command = "http"<br />
<br />
vars.http_port = "80" <br />
<br />
vars.http_timeout = "10" <br />
<br />
assign where host.vars.webserver == true<br />
<br />
}<br />
</pre><br />
<br />
La estructura del elemento anterior es idéntica a la del apply Service para mysql, simplemente cambian el nombre, el check_command, en este caso un comando http del plugin check_http, los custom attributes pasados como parámetros al comando, y la directiva assign que aplica la condición en la cual se aplicará la monitorización del servicio.<br />
<br />
Tras añadir al archivo /etc/icinga2/conf.d/mis_servicios.conf los contenidos anteriores reiniciamos el servicio<br />
<br />
<pre><br />
service icinga2 restart<br />
</pre><br />
<br />
Entramos al interfaz web de Icinga y vemos los nuevos servicios a monitorizar<br />
<br />
[[Archivo:icinga_services.png]]<br />
<br />
=== Detalles del test '''Service mysql_test''' ===<br />
<br />
[[Archivo:icinga_mysql.png]]<br />
<br />
=== Detalles del test Service nginx_test ===<br />
<br />
[[Archivo:icinga_http.png]]<br />
<br />
== Caso práctico 2. Monitorización de Sistema Windows ==<br />
<br />
Vamos a describir brevemente como podría incorporarse un host Windows a la infraestructura de monitorización de Icinga.<br />
<br />
En este Caso práctico veremos otro modo de afrontar la monitorización con Icinga. El nodo '''cliente''' a monitorizar, un host Windows, integrará las herramientas de monitorización de Icinga y se comunicará con el servidor, nodo '''master''', al que le enviará la información de monitorización recopilada. Este intercambio ser realizará de modo seguro, haciendo uso del protocolo '''SSL'''. Este escenario supone de hecho un caso de '''monitorización distribuida'''.<br />
<br />
En un escenario de este tipo se define una estructura jerárquica, en la que encontramos nodos<br />
<br />
* '''master''': En la raíz de la jerarquía<br />
* '''satellite''': Que dependen de un master o de otros satellite<br />
* '''client''': Actúan como agentes conectados a un nodo master o satellite<br />
<br />
Infraestructuras de este tipo ayudan a organizar y desplegar sistemas de monitorización arbitrariamente complejos en alta disponibilidad y fragmentando las cargas. El master podría distribuir las cargas de monitorización entre los satellite.<br />
<br />
Los nodos pueden ser organizados en elementos '''zone''', las cuales se relacionan entre sí a través de relaciones de confianza "padre-hijo".<br />
<br />
Por último tenemos los elementos '''endpoint''', que serán miembros de un elemento zone. Los miembros de una misma zona actuarán en alta disponiblidad, de modo que nodos endpoint en la misma zona balancearán las cargas de check.<br />
<br />
Aún cuando usaremos este ejemplo para ilustrarlo la monitorización distribuida puede aplicarse a hosts Windows y Linux.<br />
<br />
Necesitaremos:<br />
<br />
* Equipo corriendo '''Windows 10''' en la misma red que el servidor Icinga<br />
* Instalación de el '''paquete Icinga en Windows'''<br />
* '''Intercambio de claves SSL''' de acceso para monitorización distribuída<br />
* '''Configuración de las directivas de monitorización''' necesarias<br />
<br />
En este caso vamos a definir un nodo master y un endpoint a modo de cliente que ejecutará los chequeos y reportará al master.<br />
<br />
=== Configuración del Master ===<br />
<br />
En primer lugar necesitaremos configurar Icinga para que pueda comunicarse de modo seguro con otros host. En este modo de operación el host monitorizado, en este caso el Windows 10, correrá las herramientas de monitorización de Icinga en local, y enviará reportes periódicos al servidor sobre su estado.<br />
<br />
Para configurar el servidor Icinga como nodo master en la infraestructura de monitorización distribuida, ejecutamos:<br />
<br />
<pre><br />
icinga2 node wizard<br />
</pre><br />
<br />
Este comando lanzará un pequeño asistente al que deberemos responder "n" a la primera cuestión, la cual configurará el nodo como '''master''', a continuación facilitaremos un CN (common name) para el Nodo, en este caso '''icinga_master<br />
'''<br />
<br />
[[Archivo:Icinga2_master_setup.png]]<br />
<br />
Tras lo cual reiniciamos el servicio<br />
<br />
<pre><br />
systemctl restart icinga2.service<br />
</pre><br />
<br />
A continuación ejecutamos (si no está instalado podemos instalar el paquete '''net-tools''')<br />
<br />
<pre><br />
netstat -anpt<br />
</pre><br />
<br />
cuyo resultado nos mostrará como hay corriendo un proceso en el puerto 5665, que es el utilizado para intercomunicación entre nodos Icinga.<br />
<br />
[[Archivo:icinga2_apply_setup_config.png]]<br />
<br />
=== Configuración del host Windows a monitorizar ===<br />
<br />
Desde el equipo Windows 10 descargamos el paquete instable '''icinga2-snapshot-x86_64.msi''' desde http://packages.icinga.com/windows<br />
<br />
Una vez descargado lanzamos el .msi<br />
<br />
[[Archivo:win10_icinga.png|800px]]<br />
<br />
Seguimos el asistente pulsando Next en todos los pasos<br />
<br />
[[Archivo:Icinga_win10_2.png|800px]]<br />
<br />
Ahora ejecutaremos la configuración de Icinga en el nodo Windows 10, el cual se lanzará tras pulsar "Finish" tras la instalación del .msi anterior<br />
<br />
En la ventana del setup establecemos<br />
<br />
* El '''Instance Name''': Nombre del Nodo Windows en este caso, le asignaremos el valor '''win10''', aunque se recomienda utilizar nombres FQDN<br />
<br />
A continuación pulsamos en el botón Add de la zona "Parent/master/satelite...", en la ventaja emergente que aparece configuramos<br />
<br />
* El '''Instance Name''': En este caso correspondiente al Icinga master, que para nosotros era icinga_master, y que configuramos previamente en la máquina Debian donde corre el servidor Icinga<br />
* El '''Host''': hostname o dirección IP del master, en este caso la IP del nodo del Servidor de Icinga<br />
<br />
[[Archivo:icinga2_win10_setup.png|800px]]<br />
<br />
Activar todos los checks de las opciones de la captura anterior. Al final del asistente se instalarán las herramientas de cliente NSClient++<br />
<br />
Pulsamos "Ok" y "Next"<br />
<br />
En la siguiente captura se ve como se configura el certificado para la autenticación SSL entre master (Servidor Icinga) y el nodo cliente (Windows 10)<br />
<br />
[[Archivo:icinga2_win_setup.png|800px]]<br />
<br />
Vemos como termina el asistente de modo correcto<br />
<br />
[[Archivo:icinga2_win10_ok.png|800px]]<br />
<br />
'''NOTA'''<br />
El servicio Icinga escucha en el puerto 5665, por tanto habrá que tener en cuenta este aspecto en el firewall de Windows. El propio asistente de configuración debería activar la regla correspondiente, pero no está de más revisar ante cualquier tipo de error.<br />
<br />
=== Creación de los objetos para monitorización en el Nodo master ===<br />
<br />
En la máquina Debian 9 donde corre el servidor Icinga editamos '''/etc/icinga2/zones.conf'''<br />
<br />
El contenido de ese archivo será:<br />
<br />
<pre><br />
object Endpoint NodeName {<br />
}<br />
<br />
object Zone "master" {<br />
endpoints = [ NodeName ]<br />
}<br />
<br />
object Endpoint "win10" {<br />
host = "192.168.0.8"<br />
}<br />
<br />
object Zone "win10" {<br />
endpoints = [ "win10" ]<br />
parent = "master"<br />
}<br />
<br />
object Zone "global-templates" {<br />
global = true<br />
}<br />
<br />
object Zone "director-global" {<br />
global = true<br />
}<br />
</pre><br />
<br />
En esta configuración se establece<br />
<br />
* Un objeto '''Endpoint''' para el propio Nodo master de Icinga<br />
* Un objeto '''Zone''' para el Nodo master de Icinga al que se añade como Endpoint el propio nodo Icinga<br />
* Un objeto '''Endpoint''' que define el "otro extremo" a monitorizar, en este caso a través de el atributo '''host''' se establece la IP de la máquina Windows<br />
* Un objeto '''Zone''' para el Nodo a Windows 10 a monitorizar, podrían añadirse más elementos a la zona en el atributo '''endpoints'''. Este objeto Zone está subordinado al objeto node creado con anterioridad para el master, este aspecto se define en la directiva '''parent'''.<br />
<br />
Añadimos al final del archivo /etc/icinga2/conf.d/hosts.conf<br />
<br />
<pre><br />
object Host "win10" {<br />
import "generic-host"<br />
address = "192.168.0.8"<br />
vars.http_vhosts["http"] = {<br />
http_uri = "/"<br />
}<br />
vars.disks["disk"] = {<br />
}<br />
vars.disks["disk /"] = {<br />
disk_partitions = "/"<br />
}<br />
vars.notification["mail"] = {<br />
groups = [ "icingaadmins" ]<br />
}<br />
vars.client_endpoint = "win10"<br />
vars.os_type = "windows"<br />
vars.os_version = "10"<br />
}<br />
</pre><br />
<br />
En esta configuración se establece<br />
<br />
* Un objeto '''Host''' que define los atributos del Nodo Windows a efectos de Monitorización como ya vimos en otros ejemplos<br />
<br />
Tras la definición de estos elementos reiniciamos Icinga<br />
<br />
<pre><br />
systemctl restart icinga2.service<br />
</pre><br />
<br />
Por último, accedemos al interfaz IcingaWeb para comprobar como efectivamente se realiza la monitorización del Nodo Windows 10<br />
<br />
[[Archivo:icinga_2_win10_ready.png|800px]]<br />
<br />
==== Otros chequeos ====<br />
<br />
Utilizando el agente de monitorización '''NSClient''', el cual es compatible con Nagios e Icinga, vamos a efectuar una serie de checks adicionales al nodo Windows.<br />
<br />
En el nodo master editamos el archivo '''/etc/icinga2/conf.d/services.conf''' al que añadimos al final<br />
<br />
<pre><br />
#Monitorizar nodo Windows<br />
/* CPU */<br />
apply Service "nscp-local-cpu" {<br />
check_command = "nscp-local-cpu"<br />
command_endpoint = host.vars.client_endpoint<br />
<br />
vars.nscp_cpu_showall = true<br />
<br />
assign where host.vars.client_endpoint && host.vars.os_type == "windows"<br />
}<br />
<br />
/* Memory */<br />
apply Service "nscp-local-memory" {<br />
check_command = "nscp-local-memory"<br />
command_endpoint = host.vars.client_endpoint<br />
<br />
vars.nscp_memory_showall = true<br />
<br />
assign where host.vars.client_endpoint && host.vars.os_type == "windows"<br />
}<br />
</pre><br />
<br />
Se efectúan los checks:<br />
<br />
* '''CPU''': mediante el apply efectúa un check de CPU a los host que verifican que tienen establecido el atributo host.vars.client_endpoint y que el valor del atributo host.vars.os_type es "windows". En ese caso el check_command efectúa el check de CPU contra el objeto command_endpoint indicado or el atributo host.vars.client_endpoint, el cual establecimos en la definición del nodo Windows.<br />
* '''Memoria''': consideraciones similares se hacen para el check de memoria, en este caso cambian el check_command<br />
<br />
== Referencias ==<br />
<br />
'''Inicio rápido''': https://www.icinga.com/docs/icinga2/latest/doc/02-getting-started/<br />
<br />
'''Instalación de Icinga2''': https://www.icinga.com/docs/icingaweb2/latest/doc/02-Installation/<br />
<br />
'''Principios de monitorización con Icinga''': https://www.icinga.com/docs/icinga2/latest/doc/03-monitoring-basics<br />
<br />
'''Plugins de monitorización''': https://www.icinga.com/docs/icinga2/latest/doc/05-service-monitoring/#service-monitoring-plugins<br />
<br />
'''Monitorización Windows con NSClient++''': https://www.icinga.com/2017/07/05/monitoring-windows-clients-with-icinga-2-and-local-nsclient-checks/<br />
<br />
'''Monitorización distribuida''': https://www.icinga.com/docs/icinga2/latest/doc/06-distributed-monitoring/#roles-master-satellites-and-clients<br />
<br />
[[Monitorización|Volver]]<br />
<br />
JavierFP 19:10 09 vie 2018 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Fundamentos_de_Usuarios_e_Permisos&diff=65524Fundamentos de Usuarios e Permisos2019-02-01T10:35:25Z<p>Javierfp: /* Creación y Administración de Usuarios */</p>
<hr />
<div>== Gestión de Usuarios y Permisos ==<br />
<br />
El modelo de seguridad del Sistema Linux basa su simplicidad y robustez en la utilización del concepto de usuario y grupo para controlar este importante aspecto. Cada archivo, o directorio (que no es más que un tipo especial de archivo) tiene un propietario, un usuario. El propietario de un archivo albergará permisos sobre ése archivo, en general dispondrá de los máximos permisos sobre él, y además podrá modificar los permisos de los archivos de los que es propietario.<br />
<br />
Los demás usuarios del sistema y miembros del mismo grupo de seguridad que el propietario del archivo podrán ostentar específicamente permisos sobre él, pero nunca modificar ellos mismos los permisos de archivos que no son de su propiedad. En resumen, salvo una excepción, solo el propietario del archivo (o directorio) podrá controlar la asignación de permisos (RWX, Lectura, Escritura, Ejecución) a los demás usuarios.<br />
La excepción a la que se refiere el párrafo anterior es el '''superusuario o root'''. Todo sistema Linux crea por defecto un usuario root y es el único que tiene por defecto permisos globales y no restringidos en el sistema.<br />
<br />
Otro aspecto fundamental relacionado con la seguridad de Linux y los usuarios es el concepto de propietario de un proceso. Cuando un programa se ejecuta en el Sistema Operativo, como ya sabemos, se crea un proceso para él. Ese proceso podrá acceder a aquellos recursos a los que el propietario del programa tenga acceso. Según esto, si un programa (archivo ejecutable) es ejecutado, solamente podrá acceder a aquellos recursos del sistema (archivos, dispositivos, etc.) a los que el propietario pueda efectivamente acceder, en caso contrario obtendrá una negativo por parte del Sistema Operativo para operar con esos recursos.<br />
<br />
En Linux, al igual que en Windows, se reconoce el concepto de '''grupo''' de seguridad (o simplemente grupo). Cada usuario puede pertenecer a uno o a varios grupos de usuarios. La utilización de grupos permiten simplificar la gestión de permisos cuando tenemos que manejar grandes cantidades de usuarios, de modo que, se pueden especificar los permisos a nivel de grupos, con lo cual, indirectamente, concedemos permisos sobre los usuarios del grupo.<br />
<br />
== Permisos ==<br />
<br />
Un Permiso establece un derecho de un usuario sobre un Archivo y Directorio. Linux utiliza un modelo simple, pero potente, de gestión de Permisos de usuario. Como en Linux "todo" es un Archivo (incluídos como ya se dijo los Directorios) este modelo de seguridad afecta directamente a todos los aspectos de uso del Sistema.<br />
<br />
Existen 3 tipos de Permisos: '''r''' (read, lectura), '''w''' (write, escritura) y '''x''' (execution, ejecución)<br />
Existen 4 tipos de receptores de Permisos: '''u''' (user, el propietario del Archivo o Propietario), '''g''' (group, los usuarios miembros del mismo grupo de seguridad del usuario) '''o''' (others, los usuarios que no son ni propietarios ni pertenecen al grupo del propietario) y '''a''' (all, todos)<br />
<br />
'''Comandos para cambio de Permisos y Propietario de un Archivo o Directorio:'''<br />
<br />
'''chown''': Esta orden se utiliza para cambiar el propietario de un Archivo o Directorio. La sintaxis básica es:<br />
<br />
'''chown [-R] nuevo_usuario[:grupo_usuario] archivos'''<br />
<br />
'''Ejemplo''':<br />
<br />
<source lang=bash><br />
chown www-data:www-data /var/www<br />
</source><br />
<br />
cambia el propietario del directorio /var/www al usuario www-data y grupo www-data.<br />
La '''opción -R''' se utiliza para cambios de propietario recursivos en Directorios, es decir, modifica el propietario dentro del Directorio y en todos los Subdirectorios<br />
<br />
''' '''chmod''': Este comando es utilizado para cambiar los permisos de Archivos y Directorios<br />
<br />
'''chmod [-R] cambio archivos'''<br />
<br />
'''Ejemplo''':<br />
<br />
<source lang=bash><br />
chmod a+x /home/javier/mi_programa<br />
</source><br />
<br />
el comando anterior concede '''(+)''' el permiso de ejecución '''(x)''' a todos los usuarios del sistema '''(a)'''<br />
<br />
Esta sintaxis abreviada indica:<br />
* '''¿a quién? (u, propietario, g, ,grupo del propietario, o, otros, a, todos)''' <br />
* '''¿concede o quita? (+, concede, -, quita)'''<br />
* '''¿qué permisos? (r, lectura, w, escritura, x, ejecución)'''<br />
<br />
Hay otra sintaxis alternativa del comando chmod basada en '''máscaras'''. La máscara es un valor numérico de 3 cifras, cada una de las cuales puede tener los valores:<br />
<br />
* 0: ningún permiso'''<br />
* 4: permiso de lectura (r)'''<br />
* 5: permisos de lectura y ejecución (rx)'''<br />
* 6: permisos de lectura y escritura (rw)'''<br />
* 7: todos los permisos, lectura, escritura y ejecución (rwx)'''<br />
<br />
Por tanto los pesos de cada permiso en la expresión numérica son (notad que los valores corresponden con los pesos de las potencias de 2 según la posición de la cifra):<br />
<br />
'''r w x'''<br />
<br />
'''4 2 1'''<br />
<br />
El resultado de obtener la máscara de permisos es la suma de los permisos concedido. Así, '''rw es 6 (4+2=6)''', '''rx es 5 (4+1=5)''' y '''rwx es 7 (4+2+1=7)'''<br />
<br />
Como necesitamos especificar permisos para 3 identidades (usuario, u, grupo, g, y otros, o) '''se utilizan 3 cifras decimales''' con los valores anteriores, indicando, de izquierda a derecha, los '''permisos para usuario, grupo y otros''' respectivamente.<br />
<br />
'''Ejemplo''':<br />
<br />
'''u g o''' (user, group, others)<br />
<br />
'''7 5 4'''<br />
<br />
máscara que indica permisos de rwx (7) para el usuario (u), permisos rx (5) para los miembros del grupo del propietario y r (4) para los otros<br />
<br />
La correspondencia entre máscaras octales y permisos se ve en la siguiente tabla<br />
<br />
[[Imagen:mascaras.png]]<br />
<br />
Aplicado a las 3 identidades básicas del sistema en un listado de directorio (user, group, others):<br />
<br />
[[Imagen:permisos.png]]<br />
<br />
En la siguiente tabla vemos un resumen con las máscaras de permisos más utilizadas<br />
<br />
[[Archivo:chmod_tabla.png]]<br />
<br />
== Comandos sudo y su ==<br />
<br />
'''sudo''': Este comando se utiliza para ejecutar un programa con permisos de otro usuario. En ocasiones un programa necesita ejecutarse con más permisos que los que posee el usuario invocador para poder acceder a ciertos recursos del sistema para el que no tiene permisos suficientes. Por ejemplo, si ejecutamos con nuestro usuario:<br />
<br />
<source lang=bash><br />
cat /etc/shadow<br />
</source><br />
<br />
veremos que nos da un error de permiso denegado. Esto es porque ese archivo solo puede ser leído por root y los miembros del grupo shadow (haced un ls -la /etc para comprobarlo). Por tanto para poder visualizar el contenido de ese archivo podemos invocar el comando con permisos de root, utilizando para ello la orden sudo:<br />
<br />
<source lang=bash><br />
sudo cat /etc/shadow<br />
</source><br />
<br />
veréis que ahora sí os dejará listar el contenido de ese archivo. El motivo es que al utilizar sudo se invoca el comando al que precede con privilegios de root. Sin embargo sudo no está restringido solamente a ejecutar comandos como root, también pueden usarse otros usuarios y grupos del sistema, para ello usamos los comandos<br />
<br />
<source lang=bash><br />
sudo -u usuario comando<br />
sudo -g grupo comando<br />
</source><br />
<br />
Esta sintaxis permitiría ejecutar comandos en nombre de un usuario o grupo especificados<br />
<br />
El comportamiento de sudo está definido en el archivo '''/etc/sudoers''', el cual debe ser solamente modificado mediante el comando '''visudo''' ejecutado como root (o mediante '''sudo visudo''' con un sudoer). La sintaxis de cada línea de asignación de privilegios es:<br />
<br />
<source lang=bash><br />
USERNAME/GROUPNAME SERVERNAME=(USERNAME_RUNAS:GROUPNAME_RUNAS) COMMAND<br />
</source><br />
<br />
La línea:<br />
<br />
<source lang=bash><br />
root ALL=(ALL:ALL) ALL<br />
</source><br />
<br />
'''Significa:''' El usuario '''root''' puede ejecutar desde cualquier host (primer '''ALL''', antes del =), como cualquier usuario, segundo '''ALL''' (primero dentro del paréntesis), como cualquier grupo, tercer '''ALL''', todos los comandos, último '''ALL''' de la línea. Cuando indiquemos una lista de privilegios de ejecución para miembro de un grupo la línea debe empezar por %<br />
<br />
<source lang=bash><br />
%admin ALL=(ALL:ALL) ALL<br />
</source><br />
<br />
Los miembros del grupo admin pueden ejecutar cualquier comando<br />
<br />
También es posible definir en el archivo sudoers '''alias''' para usuarios, máquinas comandos y runas. Los alias deben definirse en letra mayúscula (Ver '''man sudo''' o '''sudo --help''' para más información)<br />
<br />
<source lang=bash><br />
User_Alias OFICINA1 = paco, luis, carlos<br />
Cmnd_Alias POWER = /sbin/shutdown, /sbin/halt, /sbin/reboot, /sbin/restart<br />
Runas_Alias WEB = www-data, apache<br />
</source><br />
<br />
Una vez definidos los alias puedo utilizarlos en las reglas de ejecución del archivo<br />
<br />
<source lang=bash><br />
OFICINA1 ALL = (WEB) ALL<br />
</source><br />
<br />
Los miembros del grupo alias OFICINA1 pueden ejecutar como usuarios '''www-data, apache''' todos los comandos con permisos de ejecución para esos usuarios<br />
<br />
En versiones recientes se puede conseguir que el usuario pueda '''invocar a sudo''' simplemente haciéndolo miembro del '''grupo sudo'''<br />
<br />
Un comando interesante es '''sudo -i''' que permite iniciar una sesión interactiva de root sin necesidad de la invocación recursiva '''sudo su'''<br />
<br />
'''su''': Este comando se utiliza para cambiar el usuario de la sesión de consola actual: Sintaxis:<br />
<br />
'''su [-] [usuario [argumentos]]'''<br />
<br />
Si se pone el - se ejecutarán los archivos de inicio del usuario (para iniciación de variables de entorno por ejemplo), en caso de que no se ponga se mantendrán las de la sesión de usuario anterior al cambio.<br />
Si no se especifica el '''usuario''' entonces se cambiará por defecto al usuario root. En algunos sistemas, como Debian o Ubuntu, el usuario root viene deshabilitado por defecto, es decir no se podrá iniciar sesión con él. Esto se hace por motivos de seguridad.<br />
Los '''argumentos''' también son opcionales y se refieren a la shell, por ejemplo -c comando ejecutaría el comando indicado en nombre del usuario indicado<br />
<br />
<source lang=bash><br />
su -<br />
</source><br />
<br />
el comando anterior cambiaría la sesión al usuario root, ejecutando sus archivos de inicio y situándolo en el home de root<br />
<br />
== Creación y Administración de Usuarios ==<br />
<br />
Linux posee, como la mayoría de Sistemas, una gestión integrada de usuarios y grupos. El soporte en el Sistema Operativo para las operaciones de definición y mantenimiento de usuarios se basa en los archivos del Sistema siguientes:<br />
<br />
'''/etc/passwd''': Archivo de texto en el que se almacenan los usuarios del Sistema. Cada línea de este archivo representa la información relativa a un usuario determinado y su sintaxis es la siguiente:<br />
'''usuario:contraseña:id:gid:descripcion:directorio_trabajo:shell'''<br />
dónde:<br />
* '''usuario''': nombre del usuario<br />
* '''contraseña''': contraseña del usuario. Actualmente, por motivos de seguridad, las contraseñas no se almacenan en este archivo, sino en /etc/shadow. Por este motivo aparecerá una "x" en este campo<br />
* '''id''': id del usuario en el Sistema<br />
* '''gid''': id del grupo principal del usuario en el Sistema<br />
* '''descripción''': breve descripción<br />
* '''directorio_trabajo''': directorio home del usuario<br />
* '''shell''': programa de intérprete de comandos, o shell, asociado al usuario<br />
<br />
'''/etc/shadow''': Archivo de texto en el que se almacena la información de contraseñas (cifradas) de los usuarios. A diferencia de /etc/passwd este archivo solo puede ser leído por root, de modo que solamente el superusuario puede ver su contenido. Con esta medida se fortaleza la seguridad de los sistemas Linux. De nuevo hay una línea por cada usuario del sistema, de modo que toda línea en /etc/passwd tendría su correspondiente en /etc/shadow. La sintaxis es:<br />
'''usuario:contraseña:ultimo_cambio:min:max:aviso:inactivo:expiración:indicador'''<br />
dónde:<br />
* '''usuario''': tiene el mismo significado que en /etc/passwd<br />
* '''contraseña''': contraseña del usuario en formato cifrado. Si el valor en este campo es '''LK''' indicará que la cuenta está bloqueada, si el campo está vacío se indicará que no hay contraseña para el usuario<br />
* '''ultimo_cambio''': número de días entre el 1 de enero de 1970 y el último cambio de contraseña<br />
* '''min''': número de días mínimo antes de cambiar contraseña<br />
* '''max''': número de días máximo de vigencia de la contraseña<br />
* '''aviso''': número de días antes de que expire la contraseña, para avisar al usuario<br />
* '''inactivo''': número de días permitidos de inactividad de la cuenta<br />
* '''expiración''': fecha en la que la cuenta ya no podrá ser usada<br />
* '''indicador''': para uso futuro, valor por defecto 0<br />
<br />
Veréis que muchas de las líneas de este archivo tienen un "'''" en el campo de contraseña. Esto indica que corresponden a cuentas de usuario con los que no se va a inicar sesión, como por ejemplo los usuarios que se crean al instalar programas, éstos tendrán los permisos mínimos necesarios para ejecutar el programa, pero no se iniciará sesión con ellos.<br />
En caso de root, el cual en Ubuntu está deshabilitado como usuario de inicio de sesión por defecto, veréis que hay un "!" en el campo de la contraseña. Para poder iniciar sesión con root directamente en Ubuntu debemos asignarle una contraseña, para ello podríamos usar los comando<br />
<br />
<source lang=bash><br />
sudo su<br />
passwd<br />
</source><br />
<br />
Las líneas de /etc/shadow correspondientes a usuarios con inicio de sesión habilitado veremos que en el campo de la contraseña se almacena un código hash de la misma, identificado con los 2 caracteres iniciales, como por ejemplo $6, el cual indica SHA-512. Más concretamente:<br />
<br />
Concentrándonos en la parte de la contraseña, tenemos que este hash se compone de tres partes separadas por el caracter $:<br />
<br />
* '''Id''': Identifica el método de encriptación utilizado: 1 para MD5; 2 o 2a para Blowfish; 3 para NT Hash; 5 para SHA-256; y 6 para SHA-512.<br />
* '''Salt''': Es utilizado por los algoritmos de encriptación, regularmente son 16 caracteres o más. El salt es una semilla de aleatorización utilizada con el propósito de que una misma contraseña en claro no genere siempre la misma cadena de caracteres cifrados, distintos salt producirán distintas versiones cifradas de la contraseña, lo cual dificulta los ataques de fuerza bruta.<br />
* '''Hash''': Esto es la "contraseña" (o hash). MD5 utiliza 22 caracteres, SHA-256 usa 43, y SHA-512 usa 86.<br />
<br />
'''Veamos un ejemplo:'''<br />
<br />
Supongamos que en /etc/shadow tenemos la línea:<br />
<br />
<source lang=bash><br />
oracle:$6$MvOuttAz$5ZUMuRkx8b2kGJ/jQvTszUQz73R1G9wM78kh1SogNRnSNARUtH9YFbRX/<br />
E9iSkcokC4Djyo86DDj39Tq5ebw4/:15057:0:99999:7:::<br />
</source><br />
<br />
Se interpretaría así:<br />
<br />
* Id=6 (SHA-512)<br />
* Salt=MvOuttAz <br />
* Hash= 5ZUMuRkx8b2kGJ/jQvTszUQz73R1G9wM78kh1SogNRnSNARUtH9YFbRX/E9iSkcokC4Djyo86DDj39Tq5ebw4/ <br />
<br />
'''/etc/group''': Archivo de texto en el que se definen los grupos de usuarios. Todo usuario tiene un grupo principal asociado, además de otros de los que también puede ser miembros. De nuevo, se define en cada línea del archivo un grupo, con la sintaxis siguiente:<br />
'''grupo:gid:lista_usuarios'''<br />
dónde:<br />
* grupo: nombre del grupo<br />
* gid: id de Sistema para el grupo<br />
* lista_usuarios: usuarios del grupo separados por comas<br />
<br />
'''Pasos para crear un usuario manualmente'''<br />
* Crear el grupo en /etc/group<br />
* Añadir el usuario en el fichero /etc/passwd y /etc/shadow, dejando la contraseña en blanco<br />
* Ejecutar el comando passwd para asignarle contraseña al usuario<br />
* Crear el directorio HOME del usuario y asignarle como propietario al usuario<br />
<br />
== Uso de comandos relacionados con la gestión de usuarios ==<br />
<br />
Existen varios comandos en Linux para automatizar, o al menos simplificar, las tareas de creación de usuarios y grupos:<br />
<br />
* '''useradd''': Comando para añadir usuario especificando toda la información como parámetros<br />
<source lang=bash><br />
useradd -m -s /bin/bash prueba<br />
</source><br />
El comando anterior crea el usuario prueba con shell /bin/bash y '''creando también automáticamente su directorio home''' (opción -m). Pueden verse más opciones de este comando ejecutando<br />
<source lang=bash><br />
useradd --help<br />
</source><br />
* '''groupadd''': Comando para añadir grupos especificando toda la información como parámetros<br />
<source lang=bash><br />
groupadd test<br />
</source><br />
El comando anterior crea el grupo test (Más opciones con la opción '''--help''' del comando)<br />
* '''usermod''': Comando para modificar un usuario existente<br />
<source lang=bash><br />
usermod -a -G test prueba<br />
</source><br />
El comando anterior añade al usuario '''prueba''' como miembro del grupo '''test'''<br />
Tras ejecutar el comando podemos comprobar que efectivamente el usuario se ha añadido al grupo con el comando<br />
<source lang=bash><br />
id prueba<br />
</source><br />
El siguiente comando:<br />
<source lang=bash><br />
usermod -p $(openssl passwd -1 abc123.) prueba<br />
</source><br />
establece la contraseña '''abc123.''' para el usuario prueba. Debemos pasar como parámetro la '''contraseña cifrada''', en este caso utilizando el algoritmo MD5, al comando '''usermod''', por ese motivo se utiliza el comando openssl para generarla. Para obtener ayuda adicional para creación de passwords del comando '''openssl'''<br />
<source lang=bash><br />
openssl passwd --help<br />
</source><br />
* '''vipw''': Comando que permite editar el archivo /etc/passwd de forma segura pues trabaja con una copia de seguridad<br />
* '''adduser''': Comando para '''añadir usuarios pero de un modo asistido''', no es necesario especificar la información como parámetros, solamente el nombre del usuario. También se puede utilizar para establecer el grupo de un usuario con la sintaxis '''adduser usuario grupo'''. Adicionalmente permite la creación de grupos con la sintaxis '''adduser --group nombre_grupo'''. La opción '''--system''' indica que se creará un usuario del sistema, con inicio de sesión deshabilitado.<br />
* '''addgroup''': Comando para añadir grupos pero de un modo asistido, simplemente especificando el nombre del grupo<br />
* '''gpasswd''': Comando para añadir usuarios a grupos. Ejemplo (añade el usuario uadmin al grupo wireshark)<br />
<br />
<source lang=bash><br />
gpasswd -a uadmin wireshark<br />
</source><br />
Sería equivalente a<br />
<source lang=bash><br />
usermod -G wireshark uadmin<br />
</source><br />
Estos comandos añadirían el usuario al grupo pero no como grupo principal. Para cambiar el grupo principal del usuario podemos usar<br />
<source lang=bash><br />
usermod -g wireshark uadmin<br />
</source><br />
El comando '''gpasswd también se puede utilizar para eliminar a usuarios de grupos'''<br />
<source lang=bash><br />
gpasswd -d usuario sudo<br />
</source><br />
Elimina a usuario del grupo sudo<br />
<br />
'''Eliminar usuarios'''<br />
<br />
Podemos hacerlo de varios formas:<br />
* Poniendo en la definición de shell el valor /bin/false<br />
* Poniendo una contraseña inválida, como '''LK'''. Pensad que en /etc/shadow se almacenan las contraseñas cifradas, por lo tanto cualquier cosa que pongáis "a voleo" no coincidirá con ninguna contraseña "real"<br />
* Eliminar al usuario eliminando la línea de /etc/passwd y /etc/shadow<br />
Ahora bien, hay que tener en cuenta que, aunque eliminemos al usuario, todos sus archivos y directorios permanecen en el sistema. Por tanto mucho cuidado si tratáis de '''reutilizar identificadores de usuario (UID)''' pues todos esos archivos y directorios aparecerían asociados al nuevo usuario.<br />
* Utilizar comandos como '''userdel''' para eliminar usuarios o '''groupdel''' para eliminar grupos (ejecutados con sudo)<br />
<br />
'''El comando id'''<br />
<br />
Este comando es útil para visualizar la información relativa a un usuario. La sintaxis es<br />
<source lang=bash>id usuario</source><br />
La salida del comando muestra el '''uid, gid, y la lista de grupos adicionales del usuario'''<br />
<br />
'''El comando getent'''<br />
<br />
Permite visualizar información de entorno relacionada con los usuarios del sistema. Si, por ejemplo el equipo está conectado a un dominio, permitirá ver, además de los usuarios locales, todos los usuarios y grupos del dominio. Veamos algún ejemplo de uso:<br />
<source lang=bash>getent passwd</source><br />
Muestra todas las cuentas de usuarios en el sistema<br />
<source lang=bash>getent group</source><br />
Muestra todas las cuentas de grupos en el sistema<br />
<br />
== Referencias ==<br />
<br />
Tutoriales sobre sudo<br />
https://www.digitalocean.com/community/tutorials/how-to-edit-the-sudoers-file-on-ubuntu-and-centos<br />
<br />
Ejemplos sudo<br />
http://www.courtesan.com/sudo/sample.sudoers<br />
<br />
Calculador de permisos chmod:<br />
http://www.wwwwdot.com/chmod-calculator/<br />
<br />
[[Comandos básicos de xestión e administración en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Permisos.png&diff=65519Archivo:Permisos.png2019-01-30T11:13:50Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Mascaras.png&diff=65518Archivo:Mascaras.png2019-01-30T11:13:41Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Introduci%C3%B3n_aos_Dominios&diff=65408Introdución aos Dominios2019-01-18T12:49:41Z<p>Javierfp: /* Grupos de Trabajo */</p>
<hr />
<div>== Notas previas ==<br />
<br />
Tradicionalmente los sistemas en entorno de red han ido evolucionando desde un modelo de administración distribuido, basado en el concepto de Grupo de Trabajo, a un modelo de administración centralizado, basado en el concepto de Dominio.<br />
<br />
=== Grupos de Trabajo ===<br />
<br />
Un grupo de trabajo es una organización de los recursos de la red. Por recursos entenderemos todos aquellos elementos que puedan ser compartidos y utilizados en ese entorno. Por ejemplo, una impresora de red, un directorio compartido, un paquete de aplicación, etc.<br />
<br />
El modelo de funcionamiento en los entornos de grupo de trabajo está basada en la compartición de recursos por las estaciones o hosts que constituyen la red. De este modo, '''cada uno de los equipos o estaciones que comparte un recurso debe controlar el acceso al mismo''', de ahí viene que hablemos de un contexto de administración distribuido asociado a los grupos de trabajo.<br />
<br />
Veamos el siguiente gráfico<br />
<br />
[[Imagen:workgroup.jpg|500px]]<br />
<br />
En él podemos ver que cada estación gestiona las cuentas de usuario que controlan el acceso a los recursos que comparte. De modo que, si un cliente quiere acceder al recurso necesitará aportar una credencial de acceso reconocida localmente por el equipo.<br />
<br />
Este modelo dificulta la gestión cuando el número de estaciones crece. Pensad que un administrador de sistemas para poder controlar este entorno necesita conocer y documentar todos los usuarios de todos los equipos que comparten recursos en la red. Según esto, cualquier cliente de un recurso compartido necesitará conocer todas las credenciales de acceso (usuario y password) de todos los recursos a los que accede en los distintos equipos de la red.<br />
<br />
En conclusión, la administración de los recursos de una red basada en grupos de trabajo es poco eficiente y en la actualidad se muestra completamente obsoleta. En los procesos de instalación por defecto de los clientes de una red se presupone una configuración en grupo de trabajo. Por ejemplo, Windows incorpora por defecto las estaciones al grupo de trabajo WORKGROUP. El proceso de adhesión a estructuras de dominio debe de realizarse posteriormente a la instalación, o bien mediante herramientas de personalización de la instalación.<br />
<br />
=== Dominios ===<br />
<br />
La respuesta a las limitaciones de los entornos de red local basadas en grupos de trabajo viene de la mano del concepto de dominio. Un dominio es una estructura de gestión centralizada de recursos distribuidos en la red. Veamos el siguiente gráfico:<br />
<br />
[[Imagen:domain.jpg|500px]]<br />
<br />
En el gráfico podemos ver como hay equipos, Controladores de Dominio (Domain Controllers, DCs), que son los que gestionan el acceso a los recursos compartidos por cualquier equipo de la red. Podemos ver en el gráfico 3 tipos de elementos:<br />
<br />
* '''Domain Controller''' (DC): Controlador de Dominio. Equipo que almacena la base de datos de miembros del dominio, recursos compartidos, permisos de acceso y configuraciones. Al ser un servicio centralizado, que en los grupos de trabajo estaba distribuido entre todos los equipos de la red, suele ser necesario replicarlo para que, en caso de desastre o avería del DC, otro DC adicional pueda seguir realizando el trabajo de gestión de identidades y control de acceso a los recursos. Por ese motivo en el gráfico vemos 2 DCs. También se hace explícito el proceso de replicación de información entre los DCs que hace que ambos dispongan exactamente de la misma información del dominio.<br />
* '''Member Server''': Servidor Miembro. Equipos que comparten recursos en la red pero que no son DC. Pueden ser, por ejemplo, servidores de archivos, servidores web, servidores de correo, servidores de aplicaciones, servidores de seguridad, etc.<br />
* '''Client Computer''': Cliente. Equipos de los usuarios finales utilizados para trabajar en el entorno de red con los recursos compartidos en la misma<br />
<br />
En los dominios se almacena información sobre múltiples aspectos. Las identidades de la red que se gestionan directamente son de 2 tipos, '''máquinas''' y '''usuarios'''. Por tanto, para poder trabajar en un entorno de dominio, es necesario que tanto el equipo desde el que se trabaja, como el usuario con el que se inicia sesión, sean identidades reconocidas y acreditadas por el dominio.<br />
<br />
Una vez que se registran equipos y usuarios en el dominio, es el momento de realizar la configuración de seguridad en los permisos y acceso a los recursos de la red. Todo este trabajo se lleva a cabo con herramientas de administración dependientes de la tecnología con la que implementemos nuestro dominio. <br />
<br />
En este curso veremos la implantación de dominios utilizando la tecnología de Microsoft Active Directory.<br />
Existen también implementaciones basadas en software libre de dominios, tanto en modalidad gratuita como comercial. En el ámbito de las libres gratuitas la más utilizada es Samba con soporte de credenciales de usuario gestionado mediante LDAP:<br />
<br />
En conclusión, las ventajas que tienen los dominios sobre grupos de trabajo son las siguientes:<br />
<br />
* Facilidad de administración<br />
* Mayor seguridad<br />
* Centralización de recursos<br />
* Facilita las políticas de Copia de Seguridad<br />
* Permite auditar y monitorizar recursos de la red<br />
* Es escalable, es decir, permite aumentar los recursos con impacto limitado<br />
* Soporta un gran número de máquinas y usuarios<br />
<br />
== Aspectos relacionados con la administración de dominios ==<br />
<br />
=== Estructura ===<br />
<br />
A lo largo de esta unidad y de la siguiente veremos herramientas y protocolos relacionados con la gestión de una infraestructura de dominio. El contexto administrativo y tecnológico es amplio, sin embargo desde un punto de vista conceptual podemos identificar los siguientes aspectos relacionados<br />
<br />
* '''Estructuras lógicas del dominio'''<br />
** Bosque<br />
** Árbol<br />
** Dominio<br />
** Subdominios<br />
** Unidades Organizativas<br />
<br />
[[Imagen:logicas.png|500px]]<br />
<br />
* '''Estructuras físicas del dominio'''<br />
** Sitios<br />
** Subredes<br />
<br />
[[Imagen:fisicas.png|500px]]<br />
<br />
* '''Miembros del dominio'''<br />
** Equipos<br />
** Usuarios<br />
* '''Recursos gestionados'''<br />
** Directorios compartidos<br />
** Impresoras<br />
** Servicios y aplicaciones<br />
* '''Políticas de administración'''<br />
** Seguridad<br />
** Directivas de grupo<br />
<br />
A modo de resumen, un dominio es un entorno de administración centralizada que permite gestionar recursos en la red. Esos recursos son distribuidos, es decir, cualquier miembro del dominio puede tenerlos en propiedad y compartirlos. Sin embargo, la gestión en sí de esos recursos se realiza de un modo centralizado y accesible, bajo las correspondientes políticas de acceso y seguridad establecidas.<br />
<br />
Para dar soporte a estructuras empresariales complejas y crecientes, se dispone de una estructura organizativa de varios niveles. El elemento de mayor nivel es el '''Bosque''', un Bosque es un conjunto de Árboles de dominio. Un '''Árbol''' es una estructura jerárquica de dominios relacionados entre sí, mediante el uso de un espacio de nombres común. El dominio es la estructura de administración independiente. Cada dominio mantiene su propia base de datos del dominio independiente de las demás. Ahora bien, es posible establecer vínculos, '''relaciones de confianza''', entre dominios dentro de arboles o bosques diferentes. De este modo usuarios de un dominio pueden acceder a los recursos de otros dominios. Estas estructuras, Bosques, Árboles y Dominios, son conocidas como estructuras lógicas. Existen también estructuras física, más centradas en la ubicación real de los recursos y en la interconexión de red. Las estructuras físicas son los '''Sitios''', es habitual que en una organización extensa un dominio pueda desplegarse en varios sitios, y las '''Subredes''', en este caso concepto referido a las redes de infraestructura. Un Sitio abarca, por lo general, una o más Subredes.<br />
<br />
Los miembros del dominio son de dos tipos, usuarios y equipos. Para que un miembro pueda trabajar en el dominio deberá tener asociada una identidad válida dentro del mismo. A través de la pertenencia de los miembros a grupos de seguridad se establecen las políticas de acceso y derechos sobre el uso de los recursos.<br />
Las labores de administración de la red, en lo relativo al comportamiento y autorizaciones de miembros del dominio (usuarios y máquinas), se establece mediante políticas administrativas denominadas '''Directivas de Grupo''', las cuales se asocian a contextos de administración concretos correspondientes a las Estructuras lógicas del dominio.<br />
<br />
=== Disponibilidad ===<br />
<br />
Una característica central, en cualquier sistema en producción de tipo crítico, como aquellos que se encargan de aspectos de seguridad o de proporcionar los recursos básicos de trabajo en un entorno TIC, es la disponibilidad. Un sistema disponible es aquel que resulta accesible en cualquier lugar y momento previstos para su utilización. Al ser un dominio una estructura fundamental en el entorno de red, será un requisito imprescindible, el que se implanten medidas que proporcionen un entorno de trabajo de '''Alta Disponibilidad'''<br />
<br />
Términos como 24x7, el cual indica 24 horas, 7 días por semana, se refieren precisamente al aspecto de alta disponibilidad de un sistema. En la práctica ningún sistema está protegido contra el fallo técnico o humano, por tanto, para proporcionar este tipo de característica, necesitaremos recurrir a medidas de apoyo basadas en la redundancia de recursos. En general, un servicio en alta disponibilidad es aquel que en, caso de falla, dispone de un respaldo que pueda asumir sus funciones y carga de trabajo. Se utiliza, habitualmente, el término clúster para referirse al aspecto de redundancia, multiplicidad, de recursos del mismo tipo y que persiguen un mismo fin.<br />
<br />
Como veremos, un DC, Controlador de Dominio, es un servidor que alberga la base de datos y datos de configuración y gestión de un dominio. Por tanto, será un candidato ideal para implantar un respaldo sobre él, es decir, en entornos de alta disponibilidad, todo DC estará redundado, para garantizar la prestación del servicio cuando otro DC falle.<br />
<br />
En las últimas versiones de Windows Server, desde 2003 en adelante, se dispone de la característica de DC multimaestro, esto es, todos los DCs en la red son iguales, sin que prevalezca uno sobre otros. Anteriormente esto no era así, existiendo 2 roles clásicos, el '''PDC (Primary Domain Controller)''' y el '''BDC (Backup Domain Controller)'''. El primero, el PDC, se ocupaba en condiciones normales de autenticar los usuarios y realizar todas las labores relacionadas con las tareas de control de la información almacenada en el dominio. Los BDC estaban ahí como DCs de reserva, ante la posibilidad de un fallo del PDC, o bien para distribuir la carga de operaciones relacionadas con el dominio. Sin embargo, solamente el PDC podía actualizar la base de datos de configuración del directorio, es decir, los BDC operaban, en presencia del PDC, como DCs de solo lectura. Este aspecto suponía una limitación importante, pues cualquier modificación en los datos del directorio debían realizarse en el PDC, en un modelo de funcionamiento denominado de '''maestro único'''.<br />
<br />
Los entornos '''multimaestro''' solucionan precisamente ese problema, permitiendo que convivan varios DC en la red que puedan modificar la base de datos del directorio, funcionando en modo colaborativo a efectos administrativos.<br />
Por tanto, en las últimas versiones de Windows Server desaparece la nomenclatura PDC, BDC, siendo todos los DC equivalentes en cuando a su capacidad y atribuciones. Sin embargo, es necesario hacer notar un aspecto importante. Aún en entornos multimaestro, hay ciertas funciones de control de dominio que solamente puede asumir un DC en la red. Estas funcionalidades se llaman '''maestros de operaciones, FSMO, Flexible Single Master Operations''' y representan roles únicos, a nivel de dominio o bosque, que solamente uno de los DC puede asumir. En caso de que un DC, que ejecuta un maestro de operaciones se caiga, otro DC de la red deberá asumir la correspondiente función de maestro de operaciones.<br />
<br />
Cuando dispongamos de varios DC en la red, éstos deberán estar sincronizados y albergar datos lo más actuales posible, que reflejen el estado más reciente de configuración del dominio. Cuando se realiza alguna actualización de información del dominio, por ejemplo un cambio en una cuenta de un usuario, ésta será registrada en primer lugar por uno de los DCs, siendo propagada a continuación, y según una política preestablecida, a los demás DCs asociados al dominio. Este proceso se conoce como '''replicación''' y constituye uno de los aspectos de administración más importantes y críticos de un dominio.<br />
<br />
[[Imagen:replicacion.png|500px]]<br />
<br />
[[Imagen:replicacion_sitio.png|500px]]<br />
<br />
En el primer gráfico vemos como se propaga una actualización a lo largo de los DCs del dominio.<br />
<br />
En el segundo observamos una configuración multisitio, esto se puede dar, por ejemplo, cuando un domino abarque varias ubicaciones geográficas dispersas. En este caso los DCs se distribuyen asociados a los sitios a los que pertenecen. '''Por ejemplo''', DCs del sitio de Madrid, DCs del sitio de Vigo, etc., todos ellos asociados al dominio de una misma empresa. A pesar de que están geográficamente dispersos, son DCs que sirven al mismo dominio y, por tanto, el proceso de replicación los abarca a todos ellos. Ahora bien, la frecuencia de actualización de DCs dentro del mismo sitio es mayor que la de DCs que pertenecen a sitios distintos. Esto es debido a que la conectividad de red en una LAN, dónde conviven los DCs en un sitio, es de un orden de magnitud mucho más elevado que la conectividad a través de una red pública, como Internet o una línea dedicada, que comunicaría a los DCs de sitios diferentes.<br />
<br />
== Labores de administración de dominios ==<br />
<br />
A modo de esquema, a continuación, resumimos los aspectos relacionados con la administración de un dominio. En la unidad siguiente se detallarán todos estos aspectos.<br />
<br />
=== Infraestructura ===<br />
<br />
* Definición de estructura lógica<br />
** Bosques<br />
* Árboles<br />
* Definición de estructura física<br />
** Sitios<br />
* Subredes<br />
* Configuración de la replicación<br />
<br />
=== Usuarios y recursos ===<br />
<br />
* Definición de Usuarios y Grupos de Seguridad<br />
* Definición de Permisos y Privilegios<br />
* Definición de Directorios Compartidos<br />
* Administración de Servicios y Aplicaciones<br />
<br />
=== Configuración ===<br />
<br />
* Administración de la Seguridad<br />
* Administración de Directivas de Grupo<br />
* Delegación<br />
* Monitorización y Auditoría<br />
<br />
== Dominios Microsoft. Active Directory ==<br />
<br />
Desde hace años Microsoft ha sido líder en el desarrollo de tecnologías para implantación de servicios de dominio en redes de pequeño, mediano y gran tamaño. Desde las primeras versiones de Windows NT Server, hasta las más recientes, Windows 2012, Microsoft ha ido evolucionando el modelo de dominio y sus funcionalidades y soporte de compatibilidad asociado. En la siguiente tabla podemos ver las principales características en función del versión de Windows Server<br />
<br />
[[Imagen:2012_versions.png|400px]]<br />
<br />
En las últimas versiones, se incorporan herramientas de gestión integral del dominio y de todos los recursos asociados. Existen varias versiones de Windows Server, las cuales difieren básicamente en el precio y en el uso máximo de recursos que pueden utilizar.<br />
<br />
[[Imagen:windows2016.JPG|500px]]<br />
<br />
[[Xeneralidades dos Sistemas Operativos|Volver]]<br />
<br />
JavierFP 13:31 18 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Windows2016.JPG&diff=65402Archivo:Windows2016.JPG2019-01-18T12:46:51Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Workgroup.jpg&diff=65391Archivo:Workgroup.jpg2019-01-18T12:37:35Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Replicacion_sitio.png&diff=65390Archivo:Replicacion sitio.png2019-01-18T12:37:27Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Replicacion.png&diff=65389Archivo:Replicacion.png2019-01-18T12:37:20Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Logicas.png&diff=65388Archivo:Logicas.png2019-01-18T12:37:11Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Fisicas.png&diff=65387Archivo:Fisicas.png2019-01-18T12:37:01Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Domain.jpg&diff=65386Archivo:Domain.jpg2019-01-18T12:36:52Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:2012_versions.png&diff=65385Archivo:2012 versions.png2019-01-18T12:36:43Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:2008_2012.png&diff=65384Archivo:2008 2012.png2019-01-18T12:36:33Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Comandos_b%C3%A1sicos_de_xesti%C3%B3n_e_administraci%C3%B3n_en_linux&diff=65374Comandos básicos de xestión e administración en linux2019-01-10T12:27:53Z<p>Javierfp: </p>
<hr />
<div>Nesta sección veremos os comandos mais empregados na administración do sistema operativo linux.<br />
{{Alerta|Linuxcommand.org:|When you are a child you use a computer by looking at the pictures. When you grow up, you learn to read and write.}}<br />
:* [[Introdución á Shell]]<br />
:* [[Primeros pasos con la shell. Comandos básicos]]<br />
:* [[Exmpresions_Regulares_en_Linux | Expresións regulares]]<br />
:* [[Administración da rede en Linux]]<br />
:* [[Actualizar_o_sistema._Instalar_e_desinstalar_paquetes|Actualizar o sistema. Instalar e desinstalar paquetes]]. <br />
:: - [[Actualizar sistema en distintas distribucións linux]]<br />
:* [[Administración de discos e particións en Linux]]<br />
:* [[Comandos para a administración de ficheiros en Linux]]<br />
:* [[Redirección de E/S en la shell Linux|Redirección de E/S na shell de Linux]]<br />
:* [[Administrar usuarios e grupos en Linux]]<br />
:* [[Fundamentos de Usuarios e Permisos]]<br />
:* [[Aspectos avanzados de Permisos]]<br />
:* [[Permisos | Permisos e seguridade en Linux]]<br />
:* [[Manter a hora dun sistema Linux]]<br />
:* [[Administración de procesos en Linux]]<br />
:* [[Empaquetar e comprimir]]<br />
:* [[Variables de contorno en Linux]]<br />
:* [[Configuración de aplicacións en Linux]]<br />
:* [[Trucos e utilidades en Linux]]<br />
:* [http://www.ajpdsoft.com/modules.php?name=news&file=article&sid=155 Más comandos Linux]<br />
<br />
<br />
--[[Usuario:Veiga|Rafael Veiga]] 18:08 15 feb 2012 (GMT)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Administraci%C3%B3n_de_procesos_en_Linux&diff=65332Administración de procesos en Linux2019-01-09T10:56:17Z<p>Javierfp: /* Comando nohup */</p>
<hr />
<div>== Introdución aos procesos en Linux ==<br />
: A definición mais simple dun proceso podería ser que é unha instancia dun programa en execución. <br />
: Aos procesos frecuentemente se lles chama "tarefas". <br />
: Así, ao '''contexto''' dun programa que está en execución é o que se chama proceso. Este '''contexto''' pode ter: máis '''procesos fillos''' xerados do principal ('''proceso pai'''), os recursos do sistema que estea consumindo, os seus atributos de seguridade (tales como o seu propietario e permisos de arquivos), etc.<br />
<br />
: Linux, como se sabe, é un sistema operativo multitarefa e multiusuario. Isto quere dicir que múltiples procesos poden operar simultaneamente sen interferirse uns cós outros. Cada proceso ten a "impresión" de que é o único proceso e que ten acceso exclusivo a todos os servizos do sistema operativo.<br />
<br />
: Programas e procesos son entidades distintas. Nun sistema operativo multitarefa, múltiples instancias dun programa poden executarse simultaneamente. Cada instancia é un proceso separado. Por exemplo, se cinco usuarios dende equipos diferentes, executan o mesmo programa ao mesmo tempo, habería cinco instancias do mesmo programa, é dicir, cinco procesos distintos.<br />
<br />
=== PID e PPID ===<br />
: Cada proceso que se inicia é referenciado cun número de identificación único coñecido como '''''Process'' ID PID''', que é sempre un enteiro positivo. Practicamente todo o que se está executando no sistema en calquera momento é un proceso, incluíndo a ''shell''. A excepción do visto ata o de agora, temos o '''kernel''' en si, que é un conxunto de rutinas que residen en memoria e ás que os procesos poden ter acceso a través de chamadas ao sistema.<br />
: O mesmo que todos os procesos teñen un atributo '''PID''', que é o número de proceso que o identifica no sistema, tamén existe un atributo chamado '''PPID'''. Este número correspóndese có número '''PID''' do proceso pai. <br />
: Todos os procesos deben de ter un proceso que figure como pai pero, entón, ¿que ocorre se un pai morre antes que algún dos seus fillos? Nese caso o '''proceso init''' adoptará a estes procesos para que non queden orfos.<br />
<br />
=== O proceso de arranque ===<br />
Cando arranca o sistema prodúcense unha secuencia de procesos que son os seguintes:<br />
: 1.- Encéndese o sistema e un circuito especial fai que a '''CPU''' execute o código almacenado na '''BIOS'''.<br />
: 2.- O código da '''BIOS''' realiza algunhas tarefas, entre as que se inclúen a comprobación do ''hardware'', a súa configuración e buscar un sector de arranque. Este sector contén o cargador de arranque ('''LILO''', '''GRUB''' ou '''GRUB2''').<br />
: 3.- O obxectivo final do cargador de arranque é atopar un '''''kernel''''' (Linux ou de calquera outro sistema operativo), cargalo na memoria e executalo.<br />
: 4.- Cando o '''''kernel''''' de Linux toma o control, realiza tarefas como inicializar dispositivos, montar a partición raíz e, por último, cargar e executar o programa inicial do seu sistema, que por defecto é ''/sbin/init''.<br />
: 5.- O programa inicial ('''''init''''') recibe a '''ID de proceso (PID) 1''', posto que é o primeiro programa a executar no sistema. Supoñendo que ''/sbin/init'' sexa o programa inicial, éste leerá un ficheiro chamado ''/etc/inittab'' para determinar que outros programas executar, entre os que, normalmente, están programas ''getty'' para accesos dende terminal, ''scripts'' de inicialización do sistema para montar máis particións ou iniciar servizos do sistema, etc.<br />
{{Alerta|Upstart|A distribución Ubuntu utiliza ''Upstart'', que xestiona as prioridades, os eventos e as dependencias entre os servizos, pero respecta o mesmo principio que ''init''.}}<br />
<br />
=== Os modos de execución e o proceso de inicialización ===<br />
: Linux baséase en "modos de execución" para determinar que funcionalidades hai dispoñibles. Os modos de execución están numerados do 0 ao 6 e cada un ten asignado un conxunto de servizos que deberían estar activos. Só os [http://en.wikipedia.org/wiki/Runlevel modos de execución] 0, 1 e 6 son estándar, o resto poden variar nas distintas distribucións de linux.<br />
: Ao iniciarse, Linux pasa a un modo de execución determinado, que se pode configurar. É importante saber cales son estas funcións e como xestionar os modos de execución para poder controlar o proceso de arranque de Linux e as operacións en curso.<br />
<br />
* '''Funcións dos modos de execución'''<br />
:* '''Modo de execución 0:''' É un modo de execución transitorio, o que significa que se emprega para que o sistema pase dun estado a outro. En concreto, cerra o sistema. En equipos con ''hardware'' moderno, o sistema apagaríase por completo. En caso contrario, espera que o usuario reinicie o sistema manualmente ou que o apague de todo.<br />
:* '''Modo de execución 1, s ou S:''' Modo monousuario. Os servizos que se inician neste modo de execución, de existir, varían en cada distribución. Emprégase, normalmente, para realizar un mantemento a baixo nivel do sistema que podería verse afectado polo seu funcionamento normal, como o redimensionado de particións.<br />
:* '''Modo de execución 2:''' En Debian e os seus derivados (como Ubuntu), é un modo multiusuario completo con '''X''' en execución e un acceso gráfico. A maioría do resto de distribucións deixan este modo de execución sen definir. Dicir que é o modo no que arranca '''Ubuntu Server'''.<br />
:* '''Modo de execución 3:''' En Fedora, Mandriva, Red Hat e a mairía das demais distribucións, trátase dun modo multiusuario cunha pnatalla de acceso por terminal (non gráfico).<br />
:* '''Modo de execución 4:''' Normalmente está sen definir por defecto, polo que está dispoñible para configuracións personalizadas.<br />
:* '''Modo de execución 5:''' En Fedora, Mandriva, Red Hat e a maioría das demais distribucións, ten o mesmo comportamento que o modo de execución 3, có engadido de que '''X''' se executa cun acceso gráfico.<br />
:* '''Modo de execución 6:''' Emprégase para reiniciar o sistema. Este modo de execución é tamén transitorio. O sistema apágase por completo e o ordenador reiníciase automáticamente.<br />
{{Alerta|Importante:|Nunca se deben empregar os modos 0 e 6 como modos de execución por defecto. Se o facemos, o sistema se apagará de inmediato ou se reiniciará unha vez que se termina de por en funcionamento. Poderíase empregar o modo de execución 1 como opción por defecto, pero o máis normal é que se empregue 2, 3 ou 5, dependendo da distribución e o uso que se lle vaia a dar ao sistema.}}<br />
: A distribución Debian (e as que derivan dela) considera tamén os niveis 2 a 5 como multiusuario, pero non establece diferencias entre estes niveis. Por defecto, como vimos, arráncase no nivel 2, onde se inicia todo, incluso, se é o caso, a interfaz gráfica.<br />
<br />
* '''/etc/inittab'''<br />
: Neste arquivo defínese o comportamento do proceso ''init'' e dos ''runlevels''. A sintaxe dunha liña é a seguinte:<br />
: '''''Id:[niveis]:acción:comando'''''<br />
: - '''Id''' : Identificador de liña sobre catro caracteres.<br />
: - '''Niveis''' : Indica se se debe ter en conta o comando para o nivel requirido. <br />
: - '''Acción''' : Tipo de acción a efectuar segundo as circunstancias para esta liña.<br />
: - '''Comando''' : O comando a executar cós seus parámetros e as redireccións.<br />
: A acción é moi importante, xa que define as actividades de ''init'' durante o arranque e cambio de nivel ([http://es.tldp.org/Paginas-manual/man-pages-es-extra-0.8a/man5/inittab.5.html manpage del inittab]).<br />
<br />
{{Alerta|Ubuntu:|Por defecto, esta distribución non ten un ficheiro ''/etc/inittab''. Se se desexa cambiar o seu modo de execución pódese crear un ficheiro ''/etc/inittab'' que só conteña a liña ''initdefault''.}}<br />
<br />
: As principais accións son as seguintes:<br />
:: · '''initdefault''' - Define o nivel por defecto durante o ''boot'' e o inicio de ''init''.<br />
:: · '''sysinit''' - Este proceso se executará durante o arranque do sistema, antes que calquera entrada ''boot'' ou ''bootwait''. O campo '''Niveis''' ignórase.<br />
:: · ''boot'', ''bootwait'', ''off'', ''once'', ''wait'',...<br />
<br />
* '''Cambio de nivel'''<br />
: Pódese cambiar de nivel despois de arrancar a máquina có comando '''/sbin/init''' ou '''/sbin/telinit''', sendo este un simple vínculo simbólico a ''init''. O seguinte comando pasa o sistema ao nivel 5:<br />
<source lang="bash"><br />
$ sudo telinit 5<br />
</source><br />
: O nivel de execución pode verse có comando '''/sbin/runlevel'''. O primeiro valor devolto corresponde ao nivel que precede o nivel actual. Unha '''N''' significa que non hai un nivel precedente. O segundo valor é o nivel actual:<br />
<source lang="bash"><br />
$ runlevel<br />
N 2<br />
</source><br />
<br />
* '''Configuración do sistema básico.'''<br />
: Sexa o que sexa o nivel de execución especificado por defecto, ''init'' inicia sempre o comando asociado ás accións ''sysinit'', ''bootwait'' ou ''boot'' no momento de arracar o sistema.<br />
: A acción ''sysinit'' é a primeira, sendo en '''Debian''':<br />
:: ''si::sysinit:'''/etc/init.d/rcS'''<br />
: Logo, máis ou menos igual en todas as distribucións, se executan as seguintes tarefas:<br />
:: - Configuración dos parámetros do núcleo presentes en '''/etc/sysctl.conf'''.<br />
:: - Instalación dos ficheiros periféricos (/dev...).<br />
:: - Configuración do reloxio do sistema.<br />
:: - Carga das táboas de caracteres do teclado.<br />
:: - Activación das particións de intercambio SWAP.<br />
:: - Definición do nome de anfitrión.<br />
:: - Control e montaxe do sistemas de ficheiros raíz.<br />
:: - Engadir os periféricos RAID, LVM ou ambos.<br />
:: - Activación das cuotas de disco.<br />
:: - Control e montaxe dos outros sitemas de ficheiros.<br />
:: - Limpeza dos bloqueos (''stale locks'') e dos ficheiros PID no caso de parada brusca.<br />
<br />
* '''Script /etc/init.d/rc'''<br />
Este ''script'' colle como parámetro o nivel de execución por defecto, ou o parámetro especificado durante a chamada manual dos comandos '''init''' ou '''telinit''' e o inicializa, sendo responsable do inicio e da parada dos servizos asociados cando o nivel de execución cambia.<br />
<br />
* '''Xestión dos niveis e dos servizos:'''<br />
O nivel de execución define os servizos que se deben iniciar para este nivel. Correspóndelle ao script '''rc''' cargar os servizos. Contrólanse os servizos (inicio, parada, reinicio, estatus, etc.) mediante ''scripts'' presentes no directorio '''/etc/init.d'''.<br />
<source lang="bash"><br />
$ cd /etc/init.d<br />
$ ls -l<br />
total 140<br />
lrwxrwxrwx 1 root root 21 dic 8 2011 acpid -> /lib/init/upstart-job<br />
-rwxr-xr-x 1 root root 4596 abr 12 13:17 apparmor<br />
lrwxrwxrwx 1 root root 21 sep 4 19:52 apport -> /lib/init/upstart-job<br />
lrwxrwxrwx 1 root root 21 oct 25 2011 atd -> /lib/init/upstart-job<br />
-rwxr-xr-x 1 root root 2444 abr 14 11:26 bootlogd<br />
lrwxrwxrwx 1 root root 21 abr 19 18:18 console-setup -> /lib/init/upstart-job<br />
lrwxrwxrwx 1 root root 21 jun 19 22:26 cron -> /lib/init/upstart-job<br />
lrwxrwxrwx 1 root root 21 sep 14 17:47 dbus -> /lib/init/upstart-job<br />
lrwxrwxrwx 1 root root 21 mar 30 2012 dmesg -> /lib/init/upstart-job<br />
-rwxr-xr-x 1 root root 1242 dic 13 2011 dns-clean<br />
lrwxrwxrwx 1 root root 21 mar 14 2012 friendly-recovery -> /lib/init/upstart-job<br />
-rwxr-xr-x 1 root root 1105 may 17 09:07 grub-common<br />
-rwxr-xr-x 1 root root 1329 abr 14 11:26 halt<br />
...<br />
</source><br />
: Para cada nivel de execución '''n''', existe un directorio '''rcn.d''' que contén vínculos simbólicos cara os servizos presentes en '''/etc/init.d''' que se queren iniciar ou parar. Este directorio pódese atopar en diferentes lugares segundo a distribución, sendo en Debian e Ubuntu '''/etc/rcn.d'''.<br />
<source lang="bash"><br />
$ cd /etc/rc2.d<br />
$ ls -l<br />
total 4<br />
-rw-r--r-- 1 root root 677 jul 26 20:23 README<br />
lrwxrwxrwx 1 root root 18 sep 25 16:24 S21quotarpc -> ../init.d/quotarpc<br />
lrwxrwxrwx 1 root root 15 sep 13 10:27 S50rsync -> ../init.d/rsync<br />
lrwxrwxrwx 1 root root 19 sep 13 10:27 S70dns-clean -> ../init.d/dns-clean<br />
lrwxrwxrwx 1 root root 18 sep 13 10:27 S70pppd-dns -> ../init.d/pppd-dns<br />
lrwxrwxrwx 1 root root 14 sep 13 10:35 S75sudo -> ../init.d/sudo<br />
lrwxrwxrwx 1 root root 21 sep 13 10:28 S99grub-common -> ../init.d/grub-common<br />
lrwxrwxrwx 1 root root 18 sep 13 10:21 S99ondemand -> ../init.d/ondemand<br />
lrwxrwxrwx 1 root root 18 sep 13 10:21 S99rc.local -> ../init.d/rc.local<br />
</source><br />
: O prefixo do nome de cada un dos vínculos define a súa orden de execución ou parada. Os seus nomes teñen a seguinte forma:<br />
:: ''[SK]nnservizo''<br />
::: - '''S''' : Start<br />
::: - '''K''' : Kill (Stop)<br />
::: - '''nn''' : Orden numérico de execución ou parada (00=primeiro, 99=último).<br />
::: - '''servizo''' : Nome do servizo.<br />
<br />
* '''Control manual dos servizos:'''<br />
: '''- Mediante ''scripts''.'''<br />
:: Este método é único por defecto en Debian.<br />
:: Cada servizo presente en '''/etc/init.d''' acepta, polo menos, dous parámetros:<br />
:: - '''start''' : o servizo se inicia.<br />
:: - '''stop''' : o servizo se para.<br />
:: Vexamos un exemplo có servidor SSH:<br />
<source lang="bash"><br />
$ sudo /etc/init.d/ssh start<br />
ssh start/running, process 1924<br />
$ sudo /etc/init.d/ssh stop<br />
ssh stop/waiting<br />
</source><br />
:: Algúns servizos poden aceptar outros parámetros como:<br />
:: - '''status''' : Facilita o estado do servizo.<br />
:: - '''probe''' : Indica se é necesario cargar a configuración (se, por exemplo, se modificaron os ficheiros de configuración).<br />
:: - '''reload / forcereload''' : Indica ao servizo que volva a ler a súa configuración.<br />
:: - '''restart''' : Para e volve a iniciar o servizo, sexa cal sexa o final da parada.<br />
:: - '''try-restart''' : Para e volve a iniciar o servizo só en caso de parada con éxito.<br />
: '''- Mediante ''scripts''.'''<br />
:: O comando '''service''' permite prescindir da ruta cara o ''script'' de inicio do servizo e utilizar simplemente o seu nome:<br />
<source lang="bash"><br />
$ sudo service ssh stop<br />
...<br />
$ sudo service ssh start<br />
...<br />
</source><br />
<br />
* '''Parada do sistema'''<br />
: Varios métodos permiten parar correctamente unha máquina en Linux.<br />
<source lang="bash"><br />
# Para apagar o ordenador:<br />
$ sudo init 0<br />
# Para reiniciar o ordenador:<br />
$ sudo init 6<br />
</source><br />
: Por outro lado, o comando máis correcto, máis propio e máis seguro para parar o sistema é '''shutdown'''.<br />
<source lang="bash"><br />
# Reinicio para dentro de 10 minutos cunha mensaxe de aviso:<br />
$ sudo shutdown -r +10 "Reinicio para mantemento en 10 minutos"<br />
# Para cancelar ese reinicio:<br />
$ sudo shutdown -c "Mantemento cancelado"<br />
# Apagar o equipo agora mesmo:<br />
$ sudo shutdown -h now<br />
# Reiniciar o equipo agora mesmo:<br />
$ sudo shutdown -r now<br />
</source><br />
: Outros comandos:<br />
: - '''halt''' ou '''poweroff''' - Para apagar o equipo. Tamén se pode facer có comando: '''shutdown -h'''<br />
: - '''reboot''' - Para reiniciar o equipo. Como vimos, tamén se pode facer có comando: '''shutdown -r'''<br />
<br />
=== systemd ===<br />
: '''systemd''' é un conxunto de ''daemons'' de administración de sistema, bibliotecas e ferramentas deseñados como unha plataforma de administración e configuración central para interactuar có núcleo do Sistema operativo GNU/Linux.<br />
: Creouse systemd para remprazar o sistema de inicio (init) herdado dos sistemas operativos estilo UNIX System V e Berkeley Software Distribution (BSD). <br />
: No proceso de arranque en Linux, é o primeiro proceso que se executa no espacio de usuario, polo tanto, tamén é proceso pai de todos os procesos fillos no espazo de usuario. <br />
: '''systemd''' deseñouse para o núcleo de Linux e programado exclusivamente para a API de Linux. Escrito por Lennart Poettering e publicado como Software libre e de código aberto baixo os termos da GNU General Public License (LGPL) versión 2.1 ou posterior.<br />
: Dende o ano 2015 prácticamente todas as distribucións Linux optaron por empregar '''systemd'''.<br />
<br />
: En systemd falamos de "unidades", que poden ser: ''services'' (.service), ''mount points'' (.mount), ''devices'' (.device) ou ''sockets'' (.socket).<br />
: - Ver o estado dunha unidade:<br />
<source lang="bash"><br />
$ systemctl status "unit"<br />
</source><br />
: - Iniciar unha unidade:<br />
<source lang="bash"><br />
$ systemctl start "unit"<br />
</source><br />
: - Parar unha unidade:<br />
<source lang="bash"><br />
$ systemctl stop "unit"<br />
</source><br />
: - Ver si una unidad está realmente activada o no:<br />
<source lang="bash"><br />
$ systemctl is-enabled "unit"<br />
</source><br />
: - Activar que una unidad se inicie en el ''boot'':<br />
<source lang="bash"><br />
# systemctl enable "unit"<br />
</source><br />
: - Desactivar una unidad para que NO se inicie en el ''boot'':<br />
<source lang="bash"><br />
# systemctl disable "unit"<br />
</source><br />
Os ''unit files'' que nos permiten configurar os procesos a arrancar gárdanse nos directorios:<br />
: /usr/lib/systemd/system/: units provided by installed packages<br />
: /etc/systemd/system/: units installed by the system administrator<br />
<br />
: Enlaces interesantes:<br />
* [http://www.tecmint.com/manage-services-using-systemd-and-systemctl-in-linux/ tecmint.com]<br />
* [https://wiki.archlinux.org/index.php/Systemd archlinux.org]<br />
* [https://www.freedesktop.org/wiki/Software/systemd/ Freedesktop]<br />
<br />
== Identificación dos procesos en Linux ==<br />
=== ps ===<br />
: O comando [http://linuxcommand.org/man_pages/ps1.html ps] é o que permite informar sobre o estado dos procesos. <br />
: '''ps''' esta baseado no sistema de arquivos '''/proc''', é dicir, lé directamente a información dos arquivos que se encontran neste directorio. Ten unha grande cantidade de opcións. <br />
: Este comando pódenos devolver moita información sobre todos os programas que corren no sistema. <br />
<source lang="bash"><br />
$ ps<br />
PID TTY TIME CMD<br />
3081 tty1 00:00:00 bash<br />
3209 tty1 00:00:00 ps<br />
$<br />
</source><br />
: Por defecto o comando ''ps'' mostra só os procesos executados polo usuario que o chama e no propio terminal. <br />
: No exemplo que se ve só se están executando o propio terminal ''bash'' e, como non, o comando ''ps''.<br />
: A saída básica devolve o ID do proceso ('''PID'''), o terminal dende foi executado ('''TTY''') e o tempo de CPU que empregou dito proceso.<br />
<br />
A utilidade ''ps'' ten moitos parámetros, vexamos algúns exemplos interesantes:<br />
<br />
* Pódense empregar os parámetros '''-a''', '''-u''' e '''-x''' para ver todos os procesos que se executan nun momento dado no equipo, incluíndo os de outros usuarios. Estes parámetros pódense empregar con e sin o guión diante: <br />
<source lang="bash"><br />
$ ps aux<br />
</source><br />
: Para ver información dun proceso en particular, por exemplo '''sshd''':<br />
<source lang="bash"><br />
$ ps aux | grep sshd<br />
root 742 0.0 0.2 49948 2816 ? Ss 16:57 0:00 /usr/sbin/sshd -D<br />
root 1173 0.0 0.3 73352 3488 ? Ss 17:45 0:00 sshd: usuario [priv]<br />
usuario 1313 0.0 0.1 73352 1756 ? S 17:45 0:00 sshd: usuario@pts/0<br />
usuario 1415 0.0 0.0 11908 888 pts/0 S+ 17:45 0:00 grep --color=auto sshd<br />
</source><br />
<br />
* Outro xeito de ver todos os procesos que corren no sistema nun momento dado:<br />
<source lang="bash"><br />
usuario@usuario-pc:~$ ps -ef<br />
UID PID PPID C STIME TTY TIME CMD<br />
root 1 0 0 21:11 ? 00:00:02 /sbin/init<br />
root 2 0 0 21:11 ? 00:00:00 [kthreadd]<br />
root 3 2 0 21:11 ? 00:00:00 [migration/0]<br />
...<br />
</source><br />
: Este exemplo emprega dous parámetros, o parámetro '''-e''', que mostra todos os procesos que corren no sistema, e o parámetro '''-f''', que expande a saída para mostrar as columnas mais usuais.<br />
* Se queremos que se mostre a saída en formato longo empregarase o parámetro '''-l''':<br />
<source lang="bash"><br />
usuario@usuario-pc:~$ ps -l<br />
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD<br />
0 S 1000 5065 5062 0 80 0 - 1427 wait pts/0 00:00:00 bash<br />
4 S 1000 5167 5088 0 80 0 - 1016 wait pts/0 00:00:00 su<br />
0 S 1000 5173 5167 0 80 0 - 1439 wait pts/0 00:00:00 bash<br />
0 R 1000 5233 5173 0 80 0 - 629 - pts/0 00:00:00 ps<br />
</source><br />
<br />
* Outro parámetro interesante é o '''-H''', este parámetro organiza os procesos en formato xerárquico, mostrando a orden na que os procesos se iniciaron. <br />
<source lang="bash"><br />
usuario@usuario-pc:~$ ps -efH<br />
UID PID PPID C STIME TTY TIME CMD<br />
root 2 0 0 16:37 ? 00:00:00 [kthreadd]<br />
root 3 2 0 16:37 ? 00:00:00 [migration/0]<br />
root 4 2 0 16:37 ? 00:00:01 [ksoftirqd/0]<br />
root 5 2 0 16:37 ? 00:00:00 [watchdog/0]<br />
root 6 2 0 16:37 ? 00:00:00 [events/0]<br />
root 7 2 0 16:37 ? 00:00:00 [khelper]<br />
...<br />
</source><br />
: A columna '''CMD''' é interesante pois nos mostra o anidamento dos procesos.<br />
<br />
* [http://es.wikipedia.org/wiki/Pgrep pgrep]<br />
: Trátase dunha utilidade de liña de comandos derivada dos comandos '''ps''' e '''grep'''.<br />
: '''pgrep''' toma unha expresión regular da liña de comandos e devolve o ID dos procesos con nome compatible con esa expresión regular.<br />
<br />
=== pstree ===<br />
O comando pstree mostra unha vista en forma de árbore (de forma xerárquica) dos procesos en execución.<br />
<br />
Para ver os PID dos procesos:<br />
<source lang="bash"><br />
# Para ver os PID dos procesos:<br />
$ pstree -p<br />
init(1)---acpi(889)<br />
|-atd(897)<br />
|-cron(896)<br />
|<br />
...<br />
|-login(938)--bash(1075)--pstree(1426)<br />
|...<br />
# Para velos por orden:<br />
$ pstree -nps<br />
...<br />
</source><br />
<br />
=== jobs ===<br />
: O comando [http://linuxcommand.org/man_pages/jobs1.html jobs] utilízase para listar procesos que se estén executando en segundo plano ou en primeiro plano. Se non devolve ningún tipo de resposta é que non hai procesos presentes.<br />
: Vexamos uns exemplos:<br />
<source lang="bash"><br />
# Mostra os traballos que se están executando en primeiro plano ou en segundo plano. <br />
$ jobs -l<br />
# Mostra só o identificador de proceso para os traballos en execución.<br />
$ jobs -p<br />
</source><br />
<br />
=== top ===<br />
O comando [http://linuxcommand.org/man_pages/top1.html top] nos permite monitorizar o sistema en tempo real, execútase dende a liña de comandos, é interactivo e, por defecto, actualízase cada 3 segundos.<br />
<br />
Vexamos que devolve se o executamos:<br />
<br />
[[Imagen:top.jpg]]<br />
<br />
Estando dentro da apliación, premendo a letra '''h''' mostra unha axuda dos posibles comandos que permiten configurar top, por exemplo, ao presionar '''s''' pregunta polo tempo en segundos de actualización, etc.<br />
<br />
A versión mellorada de ''top'' é [http://htop.sourceforge.net/index.php?page=main htop]: <br />
: - Este comando pode que non se atope instalado no noso equipo, polo que será preciso instalalo.<br />
<source lang="bash"><br />
$ sudo apt-get install htop<br />
</source><br />
: - Para executalo:<br />
<source lang="bash"><br />
$ sudo htop<br />
</source><br />
: E nos atoparemos unha saída como esta:<br />
[[Imagen:htop.png]]<br />
: · Unha das características é que nos podemos mover polas tarefas.<br />
: · Podes modificar o xeito de mostrar os procesos en pantalla presionando "F2" e logo escollendo as opcións axeitadas.<br />
: · Pódense ordenar as tarefas por CPU, Memoria, Tempo, PID,... o xeito de facelo é presionando "F6" e logo escollendo a opción que máis nos interese.<br />
: · Tamén podes facer un filtro polo nome do proceso pulsando "F4".<br />
: · Tamén podes matar un proceso directamente poniéndote sobre el y pulsando "F9".<br />
<br />
== Matar un proceso ==<br />
=== kill ===<br />
: O comando [http://linuxcommand.org/man_pages/kill1.html kill] emprégase para finalizar procesos en linux.<br />
: Para finalizar un proceso empregando o comando '''''kill''''' é preciso coñecer o número de identificación do proceso ('''PID''') ou o número da tarefa. <br />
: Para coñecer estes números basta con listar os procesos empregando o comando '''ps'''.<br />
: Unha vez coñecido o PID basta con executar nun terminal: <br />
<source lang="bash"><br />
$ kill [PID]<br />
</source><br />
: Tamén podemos matar a tarefa:<br />
<source lang="bash"><br />
$ kill %[Numero tarefa]<br />
</source><br />
: É conveniente comprobar que o proceso finalizou e xa non se atopa en execución.<br />
: Pode suceder en ocasións que algún proceso non finalice logo de executar '''kill'''. Nestes casos pódese intentar finalizalos có comando '''kill''' e un sinal mais forte que forza os procesos a rematar mais aló da súa vontade, como por exemplo:<br />
<source lang="bash"><br />
$ sudo kill -9 [PID]<br />
</source><br />
: Matar un proceso e todos os seus procesos fillos:<br />
<source lang="bash"><br />
$ sudo kill -TERM [PPID]<br />
# Utilizando pgrep para matar apache2 e todos os seus procesos fillos:<br />
$ sudo kill -TERM -$(pgrep -f apache2)<br />
# Con pgrep -f buscamos polo nome do proceso<br />
</source><br />
<br />
'''Exemplo:'''<br />
<br />
Para saber cal é o PID dun proceso podemos executar un *ps aux* previo para coñecer o PID a partires do nome do comando:<br />
<br />
<source lang="bash"><br />
ps aux | grep bash<br />
</source><br />
<br />
Mostraría algo así:<br />
<br />
<source lang="bash"><br />
USER PID<br />
<br />
1000 3114 ...etc<br />
</source><br />
<br />
O interesante é a parte correspondente á segunda columna (PID), entón escribiriamos:<br />
<br />
<source lang="bash"><br />
kill SIGKILL 3114<br />
</source><br />
<br />
(SIGKILL é o mesmo que poñer -9, facer un kill -l para comprobar que o sinal 9 corresponde a SIGKILL)<br />
<br />
'''Co comando *pidof* obteremos o, ou os PID, asociados a un determinado proceso a partir de nome do mesmo'''<br />
<br />
<source lang="bash"><br />
echo $(pidof soffice)<br />
</source><br />
<br />
=== pkill ===<br />
<br />
Este comando é moi útil, pois permite matar un proceso utilizando o seu nombre. Deste xeito o seu funcionamento é similar a kill acompañado de pidof<br />
<br />
<source lang="bash"><br />
sudo pkill soffice<br />
</source><br />
<br />
Mata o proceso soffice (asociado a libreoffice)<br />
<br />
=== killall===<br />
: As veces ocorre que, ao listar os procesos activos, o que se desexa finalizar ten distintas instancias abertas, é dicir, dispón de varias PID e para finalizalo precísase utilizar varias veces o comando '''kill'''. O comando [http://linuxcommand.org/man_pages/killall1.html killall] utilízase para finalizar todos os procesos que abre un comando. <br />
: Como se pode supoñer, ao dispor de distintas PID non é este dato o que se debe indicar ao comando '''killall''' senón o nome do proceso. Este nome ven dado no listado de procesos como '''CMD'''; entón: <br />
<source lang="bash"><br />
$ sudo killall [CMD]<br />
</source><br />
<br />
===xkill===<br />
: O comando [http://linuxcommand.org/man_pages/xkill1.html xkill] é unha utilidade para forzar o Servidor X a cerrar conexións. Este comando pódese utilizar como o comando '''kill''':<br />
<source lang="bash"><br />
$ sudo xkill -id [PID]<br />
</source><br />
: Este comando pódese empregar sen necesidade de indicar o PID, xa que se se introduce nun terminal:<br />
<source lang="bash"><br />
$ xkill<br />
</source><br />
: O cursor cambiarase a unha caveira e a aplicación matará o proceso que controle a fiestra onde se faga ''click'' coa caveira.<br />
<br />
== Pausar un proceso ==<br />
: Para pausar un proceso, como para matalo, é preciso coñecer o número de identificación do proceso (PID).<br />
: Unha vez coñecido o PID basta con executar no terminal:<br />
<source lang="bash"><br />
$ sudo kill -STOP [PID]<br />
</source><br />
: Para reanudalo basta con teclear:<br />
<source lang="bash"><br />
$ sudo kill -CONT [PID]<br />
</source><br />
<br />
== Procesos en primeiro e segundo plano: ''fg'' e ''bg'' ==<br />
Para traballar con procesos en primeiro e segundo plano Linux ten as ferramentas [http://linuxcommand.org/man_pages/fg1.html fg] e [http://linuxcommand.org/man_pages/bg1.html bg].<br />
<br />
Pódese lanzar un proceso de xeito normal (en primeiro plano), paralo e despois relanzalo en segundo plano.<br />
=== fg ===<br />
Vexamos un exemplo no que se empregará a utilidade [http://linuxcommand.org/man_pages/yes1.html yes] e [http://linuxcommand.org/man_pages/fg1.html fg]. <br />
<source lang="bash"><br />
# Lanzamos a utilidade "yes"<br />
$ yes<br />
# Pausamos a execución da utilidade<br />
# premendo Control + Z<br />
# Comprobamos que "yes" está detido:<br />
$ jobs<br />
[1]+ Detenido yes<br />
# Reanudamos a execución da tarefa <br />
# empregamos o comando "fg":<br />
$ fg %1<br />
# Paramos completamente a execución da utilidade<br />
# premendo Control + C<br />
</source><br />
<br />
=== bg ===<br />
Para executar un comando directamente en segundo plano podemos facelo introducindo o carácter "&" ao final:<br />
<source lang="bash"><br />
# Lanzamos "yes" en segundo plano<br />
# enviando a súa saida a "null"<br />
$ yes > /dev/null &<br />
[1] 746<br />
# Vemos que nos devolve o número de tarefa<br />
# e, ademais, o PID<br />
$ jobs<br />
[1]+ Ejecuntando yes > /dev/null &<br />
$ ps<br />
746 tty1 00:10:10 yes<br />
# Matamos a tarefa<br />
$ kill %1<br />
$ jobs<br />
[1]+ Terminado yes > /dev/null<br />
</source><br />
Vexamos un exemplo no que se empregará a utilidade [http://linuxcommand.org/man_pages/yes1.html yes] e [http://linuxcommand.org/man_pages/fg1.html bg]. <br />
<source lang="bash"><br />
# Lanzamos a utilidade "yes"<br />
# a súa saída a redireccionamos a "null"<br />
$ yes > /dev/null<br />
# Pausamos a execución da utilidade<br />
# premendo Control + Z<br />
# Comprobamos que "yes" está detido:<br />
$ jobs<br />
[1]+ Detenido yes > /dev/null<br />
# Reanudamos a execución da tarefa <br />
# empregamos o comando "bg":<br />
$ bg %1<br />
[1]+ yes > /dev/null &<br />
# Comprobamos con "jobs" que o comando segue executándose<br />
$ jobs<br />
[1]+ Ejecutando yes > /dev/null &<br />
# Paramos completamente a execución da utilidade:<br />
$ kill %1<br />
# E miramos se segue en execución:<br />
$ jobs<br />
[1]+ Terminado yes > /dev/null<br />
</source><br />
<br />
: Vemos que utilizando '''&''' ao final executamos o comando e liberamos o terminal.<br />
:<br />
<br />
= Utilidades de manexo de servizos ao inicio =<br />
'''---- Depreciadas, a día de hoxe a maioría das distribucións empregan systemctl xa explicada antes ----'''<br />
:<br />
As utilidades [http://linux.die.net/man/8/chkconfig chkconfig], [http://manpages.ubuntu.com/manpages/hardy/man8/sysv-rc-conf.8.html sysv-rc-conf] e [http://manpages.ubuntu.com/manpages/hardy/es/man8/update-rc.d.8.html update-rc.d] poden usarse para activar ou desactivar servizos. <br />
<br />
== chkconfig ==<br />
O comando '''chkconfig''' emprégase para cambiar, actualizar e consultar información de ''runlevel'' para os servizos do sistema. <br />
<br />
Opcións:<br />
: '''--add servicio''' : Crea un inicio en cada ''runlevel'' especificado para o servizo especificado de acordo ao comportamento por defecto especificado no script de inicialización do servicio.<br />
: '''--list''' : Mostra se o servizo especificado está activo ou non en cada nivel. <br />
: '''--level números''' : Especifica mediante números un ou varios niveis de execución a cambiar. <br />
: '''--del servicio''' : Elimina entradas para o servizo especificado en todos os niveis de execución.<br />
<br />
'''Exemplos:'''<br />
* Ver unha lista dos servizos do sistema e se estos están arrancados (''on'') ou detidos (''off'') nos niveis de execución 0-6.<br />
<source lang="bash"><br />
$ chkconfig --list<br />
</source><br />
* Agregar o servicio web('''''httpd''''') nos modos de execución por defecto:<br />
<source lang="bash"><br />
$ chkconfig --add httpd<br />
</source><br />
* Agregar o servicio web ('''''httpd''''') e facer que arranque nos niveis 2, 3, 4 e 5:<br />
<source lang="bash"><br />
$ chkconfig --level 2345 httpd on<br />
</source><br />
* Eliminar o servicio web('''''httpd''''') do listado de servicios: <br />
<source lang="bash"><br />
$ chkconfig --del httpd<br />
</source><br />
* Deshabilitar o servicio web('''''httpd''''') no nivel de execución 5:<br />
<source lang="bash"><br />
$ chkconfig --level 5 httpd off<br />
</source><br />
<br />
== update-rc.d ==<br />
O comando '''update-rc.d''' permítenos automatizar o proceso de creación e borrado de enlaces aos ''scripts'' de inicio, có fin de iniciar/parar servizos.<br />
<br />
'''Exemplos con update-rc.d'''<br />
* Se queremos eliminar servizos do proceso de arranque, non temos máis que executar o seguinte comando: '''update-rc.d -f nome_proceso remove'''<br />
<source lang="bash"><br />
# Eliminar o proceso squid do arranque:<br />
$ update-rc.d -f squid remove<br />
</source><br />
<br />
* Se queremos crear enlaces usando parámetros por defecto, executaremos: '''update-rc.d nome_proceso defaults'''<br />
<source lang="bash"><br />
# Crear enlace a squid empregando os parámetros por defecto:<br />
$ update-rc.d squid defaults<br />
</source><br />
<br />
: Con esta opción crearanse enlaces para arrancar o servizo nos niveis de execución 2345 e parar o servizos nos niveis de execución 016. Por defecto, todos os enlaces terán o código de secuencia 20.<br />
<br />
* Se preferimos especificalo todo:<br />
<source lang="bash"><br />
# Crear enlaces para arrancar o servizo ssh nos niveis 2345 <br />
# e paralo nos niveis 016. O código de secuencia sería 20.<br />
$ update-rc.d ssh start 20 2 3 4 5 . stop 20 0 1 6 .<br />
</source><br />
<br />
= Outros comandos =<br />
<br />
== netstat e lsof ==<br />
<br />
A veces resulta útil coñecer a qué proceso está vinculado un servicio TCP/IP, é dicir un servicio que esté funcionando en rede e que admita peticións de clientes<br />
<br />
Podemos visualizar esta información utilizando<br />
<br />
'''netstat -anp | grep numero_porto'''<br />
<br />
<source lang="bash"><br />
netstat -anp | grep 80<br />
</source><br />
<br />
ou mediante lsof -i:numero_porto<br />
<br />
<source lang="bash"><br />
lsof -i:80<br />
</source><br />
<br />
Os exemplos anteriores mostrarían a información do servizo vinculado ó porto 80 TCP. Si quixéramos ver con netstat a información relativa a portos UDP usariamos a opción -u<br />
<br />
== Comando nohup ==<br />
<br />
Cando se crea un proceso, por exemplo mediante a invocación dun comando, éste crearase como fillo do contexto no que se crea. Si estamos traballando nunha sesión de terminal e escribimos:<br />
<br />
<source lang=bash><br />
find / -user `whoami` > `whoami`.proc<br />
</source><br />
<br />
Buscaría en todo o sistema aqueles arquivos e directorios que son propiedade do usuario que realiza a invocación e garda o resultado da búsqueda nun arquivo '''<nombre_usuario>.proc.''' Notade que `whoami` devolvería o nome do usuario que o invoca.<br />
Esta búsqueda pode levar o seu tempo e, si durante ese proceso necesitamos ausentarnos e pechar a terminal, o proceso deixaría de executarse, pois foi creado como fillo da shell da sesión da terminal actual que, de deterse, causaría que se eliminaran todos os seus procesos fillos.<br />
<br />
Para evitar este comportamento podemos usar o comando '''nohup'''. Este comando, seguido do comando que se vai a executar a continuación, causa que éste non se execute como fillo da shell dende a que se invoca, senón como un proceso nun nivel superior que, no caso de cerrarse a shell, non se eliminará ó non tratarse dun proceso fillo da mesma.<br />
<br />
<source lang=bash><br />
nohup find / -user `whoami` > `whoami`.proc<br />
</source><br />
<br />
Ahora sí podería pecharse a shell e o proceso de búsqueda continuaría ata a súa finalización<br />
<br />
[[Comandos básicos de xestión e administración en linux|Volver]]</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Edici%C3%B3n_de_textos&diff=65311Edición de textos2019-01-08T19:52:00Z<p>Javierfp: /* Referencias */</p>
<hr />
<div>== Vi y Vim ==<br />
<br />
Vim es un potente editor, descendiente del clásico vi, que integra capacidades avanzadas de edición de archivos de texto. Es un editor que requiere cierto tiempo de adaptación, ya que no es tan intuitivo como otros editores como nano.<br />
Vim opera en dos modos de trabajo, el '''modo de edición''' y el '''modo normal'''. En el primero podremos editar los contenidos del fichero, mientras que el segundo se utiliza para ejecutar comandos relacionados con la gestión de aspectos no relacionados con la edición del texto, como por ejemplo borrados, sustituciones, búsquedas, etc.<br />
<br />
Para acceder al modo de edición pulsamos la tecla '''i'''. Para acceder al modo normal pulsamos la tecla '''Esc'''.<br />
<br />
=== Comandos básicos en el modo normal para gestionar el guardado, salida y edición de otro archivo ===<br />
<br />
"Listado de comandos de vi":http://www.cs.colostate.edu/helpdocs/vi.html<br />
<br />
* ''':q''' Salir del editor sin guardar (quit)<br />
* ''':q!''' Salir del editor sin guardar ni pedir confirmación (quit ya!)<br />
* ''':wq!''' Salir del editor guardando sin pedir confirmación (write and quit ya!)<br />
* ''':w f2.txt''' Guardar en un fichero llamado f2.txt y seguir <br />
* ''':e f1.txt''' Cierra el fichero actual y abre f1.txt (edit f1.txt)<br />
<br />
=== Desplazamientos, inserciones y sustituciones ===<br />
<br />
* '''w''': salta al inicio de las palabras<br />
* '''b''': salta palabra a palabra hacia atrás<br />
* '''e''': salto al fin de las palabras<br />
* ^: salto al primer carácter no blanco al inicio de línea<br />
* '''0''': salta al inicio de línea<br />
* $: salto al fin de línea<br />
* '''x''': elimina el carácter actual<br />
* '''X''': elimina el carácter anterior<br />
* '''o''': inserta línea debajo de la línea actual<br />
* '''O''': inserta línea antes de la línea actual<br />
* '''i''': inserta texto antes de posición actual<br />
* '''I''': insertar al principio de línea<br />
* '''p''': pega el contenido del búfer después del cursor<br />
* '''P''': pega el contenido del búfer antes del cursor<br />
* '''ce''': sustituye la palabra actual<br />
* '''C:''' sustituye toda la línea actual<br />
* '''a''': inserción de texto a continuación del cursor<br />
* '''A:''' inserción de texto al final de la línea<br />
<br />
=== Uso de las flechas del teclado ===<br />
<br />
Aunque se recomienda el uso de las teclas '''h, j, k, l''' para desplazamientos por el texto en modo normal, al principio es más intuitivo hacerlo con las flechas del teclado. Para habilitar esta capacidad, ya que en algunas terminales estas teclas son interpretadas como caracteres de escape y escriben los códigos en el editor vim, añadiendo símbolos extraños al texto, editamos el archivo '''.vimrc''' dentro del directorio home del usuario, y añadimos las líneas:<br />
<br />
<pre><br />
nnoremap <Left> h<br />
nnoremap <Right> l<br />
nnoremap <Up> k<br />
nnoremap <Down> j<br />
inoremap <left> h<br />
inoremap <right> l<br />
inoremap <up> k<br />
inoremap <down> j<br />
</pre><br />
<br />
=== Comandos para copiar, cortar y pegar texto ===<br />
<br />
'''Copiado'''<br />
* '''yw''': Copia la palabra en la posición del cursor, para copiar toda la palabra éste debe estar posicionado al principio de la misma<br />
* '''yy''': Yank (copiado) de la línea actual<br />
* '''y$''': copia de la posición actual del cursor al fin de línea<br />
* '''y0''': copia de la posición actual del cursor al principio de línea<br />
* '''5yy''': copia 5 líneas<br />
<br />
'''Pegado'''<br />
* '''p''': pega después del cursor<br />
* '''P''': pega antes del cursor<br />
<br />
En el modo normal (Esc) pulsamos '''v''' (visual), entraremos en modo seleccionar. Nos desplazamos por el cursor para abarcar el texto seleccionado y pulsamos '''c''' para cortar el texto o '''y''', para copiarlo. Para pegar el texto copiado o cortado pulsamos, en la posición destino, '''p'''<br />
Otro modo más sencillo para cortar es utilizar '''dd''', al utilizar este comando se corta la línea actual, o varios si ponemos dn (n númerode líneas a cortar), pero se copia en el registro por defecto, al estilo portapapeles, luego usamos '''p''' y pegamos el contenido del registro en la posición indicada<br />
<br />
'''Reemplazo'''<br />
* '''r''': Reemplaza el carácter bajo el cursor<br />
* '''R''': Reemplaza a partir del carácter bajo el cursor<br />
* '''cw''': Reemplaza la palabra actual<br />
* '''C''': Reemplaza desde el carácter del cursor hasta el final de línea<br />
<br />
'''Borrado'''<br />
* '''dd''': Borra toda la línea actual<br />
* '''dNd''': Borra las N líneas a continuación<br />
* '''dw''': Borra la palabra bajo el cursor<br />
* '''D''': Borra desde el cusor hasta el final de línea<br />
* '''d0''': Borra desde la posición del cursor hasta el principio de línea<br />
<br />
=== Comandos para operaciones con texto ===<br />
<br />
* '''dd''' Suprimir línea actual al buffer (p para pegar) (delete)<br />
* '''u''' Deshacer el último cambio en el fichero (undo)<br />
* '''CTRL+R''' Rehacer el último cambio en el fichero (redo)<br />
* '''guu''' Convertir a minusculas la línea actual (lowercase)<br />
* '''gUU''' Convertir a mayúsculas la línea actual (UPPERCASE) <br />
* ''':num''' Posicionarse en la línea num del fichero <br />
* '''gg''' Posicionarse al principio del fichero<br />
* '''G''' Posicionarse al final del fichero<br />
* '''ga''' Muestra código ASCII, hex y octal del caracter actual<br />
<br />
=== Búsqueda y sustitución con vim ===<br />
<br />
En modo normal<br />
<br />
* '''Buscar texto''':<br />
** ''':/palabra''' (pulsaremos '''n''' para ir a la siguiente ocurrencia o '''N''' para la anterior)<br />
* '''Sustituir texto''':<br />
** ''':%s/texto1/texto2''' sustituye texto1 por texto2 en la línea actual<br />
** ''':%s/texto1/texto2/g''' con la terminación /g se sustituyen todas las ocurrencias de texto1 por texto2, sino se indica se sustituye la primera ocurrencia<br />
** ''':%s/texto1/texto2/gi''' igual que la anterior pero case insensitive<br />
** '''5,12s/texto1/texto2''' sustituye en el rango de líneas 5 a 12 texto1 por texto2<br />
** ''':'<,'>s/texto1/texto2''' en modo visual sustituye en la selección texto1 por texto2 (el '<,'> se incluye automáticamente tras la selección visual)<br />
** ''':g/^baz/s/texto1/texto2/g''' cambia en todas las líneas que empiecen por baz texto1 por texto2<br />
** ''':.,$s/texto1/texto2/g''' cambia todas las ocurrencias de texto1 por texto2 desde la línea actual hasta el final del archivo<br />
** ''':.,+2s/texto1/texto2/g''' cambia todas las ocurrencias de texto1 por texto2 en la línea actual y las 2 siguientes<br />
<br />
=== Autocompletar ===<br />
<br />
Puede usarse '''autocomplección''':<br />
<br />
* Utilizando palabras en el propio archivo en modo inserción con '''ctrl+n''', ocurrencia siguiente, o '''ctrl+p''', ocurrencia posterior. Aparecerá una lista con las sugerencias encontradas<br />
* Utilizando rutas en el sistema de archivos, usando '''ctrl+x''' '''ctrl+f'''<br />
* '''Autocompletar utilizando un archivo externo a modo de plantilla:'''<br />
Puede hacerse también abriendo en la misma sesión de vim otro archivo del que tomar las palabras para autocompletar a modo de diccionario, por ejemplo para insertar directivas tomadas de un archivo de configuración de pruebas. Para ello usamos ''':split archivo_plantilla''', esto abrirá el archivo en modo split, dividiendo el área de trabajo. Saltamos con '''ctrl+w''' al área anterior y ya podemos, en modo inserción, utilizar el autocompletado con '''ctrl+n''' y '''ctrl+p''' tomando las palabras del archivo incluído.<br />
<br />
=== Opciones de configuración ===<br />
<br />
En el archivo '''vimrc''', suele estar en '''/vimrc''', se definen las opciones de configuración de vim. Algunas<br />
<br />
* ''':set ts=3''' Fija los tabulados a 3 espacios<br />
* ''':set sw=3''' Fija los indentados a 3 espacios<br />
* ''':set number/nonumber''' Activa/desactiva el numerado en los ficheros<br />
* ''':set backup/nobackup''' Activa/desactiva la copia de seguridad automática<br />
* ''':set directory=dir''' Fija la carpeta donde se harán las copias<br />
* ''':syntax on/off''' Activa/desactiva el resaltado de sintaxis<br />
* ''':color esquema''' Cambia color del vim (evening, darkblue, desert, elflord, koehler, morning...)<br />
* ''':set cindent''' Activa indentado automático<br />
* ''':set mouse=a/mouse=''' Activa/desactiva el uso del ratón<br />
* ''':set paste/nopaste''' Activa/desactiva el modo pegar texto literalmente<br />
* ''':spell''' Activa el corrector ortográfico<br />
* ''':setlocal spell spelllang=es''' Activa el idioma español del corrector ortográfico<br />
* ''':set spellfile=~/.vimdic''' Fija diccionario de palabras desconocidas<br />
<br />
=== Ejecutar comandos externos ===<br />
<br />
Es posible que mientras estamos editando un fichero, necesitemos ejecutar un comando (por ejemplo, un ls para ver los archivos), esto se puede hacer escribiendo en el modo normal ''':!comando''', en nuestro ejemplo: ''':!ls'''. También se puede hacer una pausa en la edición escribiendo ''':shell''' para realizar alguna operación y cuando la terminemos, escribir '''exit''' y volver al editor. Incluso los comandos ''':make''' y ''':cc''' se pueden utilizar para ahorrarnos el estar saliendo del editor para hacer makes o ver el último error que nos dió.<br />
<br />
=== Editar varios ficheros a la vez ===<br />
<br />
Con ''':split fichero''' (división horizontal) o ''':vplit fichero''' (división vertical) pueden editarse varios archivos de texto a la vez. Para conmutar de unas a otras áreas de edición se utilizaría '''CTRL+W''' y desplazamiento con cursor. <br />
<br />
Pueden utilizarse también varias pestañas, al estilo Firefox, para ello escribimos en modo normal ''':tabnew fichero'''. Para movernos con ellas utilizamos ''':tabn''', y pulsando > o con el ratón movernos por ellas.<br />
<br />
=== Otros comandos útiles ===<br />
<br />
* '''CTRL+N''': Autocompletar texto<br />
* '''=G''' Indenta automáticamente todas las líneas de un fichero<br />
* '''{}''' Detecta donde está la llave mal cerrada del párrafo actual<br />
* :g/^\s'''$/d Elimina las líneas en blanco de un fichero<br />
<br />
=== Algunos trucos ===<br />
<br />
* '''ELIMINAR LÍNEAS EN BLANCO DE UN ARCHIVO''': Desde el modo :, ejecutamos '''g/^$/d'''. La opción g sirve para indicar una expresión de regular de búsqueda, en este caso '''^$''' (líneas vacías) y a continuación indica una acción a realizar con esas líneas, en este caso la opción '''d''' (borrar)<br />
* '''ELIMINAR LÍNEAS DE COMENTARIO''': Igual que en el ejemplo anterior, la expresión sería '''g/^*/d'''<br />
<br />
=== Listado completo de comandos vim ===<br />
<br />
[[Archivo:ChuletaVim-simple.jpg]]<br />
<br />
INVOCACIÓN VI.<br />
<br />
$vi————————Editar un texto sin nombre<br />
$vi archivo—————-Editar un archivo (nuevo o no)<br />
$vi archivo1 archivo2——Editar lista de archivos<br />
$vi +n archivo————-Editar archivo en la línea n<br />
$vi +/txt archivo———-Editar archivo en la 1a línea donde aparece txt<br />
<br />
MOVIMIENTOS DEL CURSOR.<br />
<br />
Arriba—-k<br />
Abajo—–j<br />
Derecha—h<br />
Izquierda-l<br />
<br />
0———Inicio de línea<br />
$———Fin de línea<br />
w———Word: Avanzar palabra<br />
b———Back: Retroceder palabra<br />
e———End: Al final de palabra<br />
H———Home: Esquina sup. izq. de la ventana<br />
L———Last: Esquina inf. izq. de la ventana<br />
crtl+u—-Window up: Subir ventana<br />
crtl+d—-Window down: Bajar ventana<br />
crlt+b—-Page back: Retroceder página<br />
crtl+f—-Page forward: Avanzar página<br />
nG——–Go: Salta a la línea n.<br />
1G——–A la primera línea<br />
$G——–A la última línea<br />
fcar——Buscar en la línea el carácter car (hacia delante)<br />
Fcar——Buscar en la línea el carácter car (hacia atrás)<br />
INSERTAR TEXTO.<br />
<br />
i—Insertar (delante del cursor)<br />
I—Insertar al principio de la línea<br />
a—Añadir (detrás del cursor)<br />
A—Añadir al final de la línea<br />
o—Insertar una línea debajo de la actual<br />
O—Insertar una línea encima de la actual<br />
BORRAR TEXTO.<br />
<br />
x—Borrar caracter actual<br />
X—Borrar caracter anterior<br />
dd–Borrar línea actual<br />
D—Borrar hasta final de línea<br />
dw–Borrar palabra<br />
CAMBIAR TEXTO.<br />
<br />
rcar–Reemplazar el caracter actual por car<br />
R—–Reemplazar texto desde la posición del cursor<br />
s—–Substituir el caracter actual por texto a insertar<br />
S—–Substituir la línea actual<br />
C—–Cambiar hasta el final de la línea<br />
cw—-Cambiar palabra<br />
J—–Unir a la línea actual la siguiente<br />
COPIAR Y PEGAR.<br />
<br />
yy—-Copiar en el buffer la línea actual<br />
nyy—Copiar en el buffer n líneas desde la actual<br />
p—–Pega el buffer detrás del cursor<br />
P—–Pega el buffer delante del cursor<br />
BUSCAR Y SUBSTITUIR.<br />
<br />
%——————-Busca el caracter delimitador ( ) [ ] { } que balancea el actual (Dentro de un entorno salta al<br />
<br />
delimitador inicial)<br />
/ExpReg————-Busca hacia delante la expresión regular ExpReg<br />
?ExpReg————-Busca hacia atrás la expresión regular ExpReg<br />
n——————-Repite la última búsqueda<br />
N——————-Repite la última búsqueda en el sentido contrario<br />
:s/txt/txt2———Substituye el texto txt por txt2 la primera vez que aparece en la línea<br />
:s/txt/txt2 /g——Substituye todas las apariciones de txt por txt2 en la línea<br />
:m,n s/txt/txt2 /g–Substituye en el rango de líneas [m,n]<br />
REPETIR Y DESHACER.<br />
<br />
.—Repetir último comando de actualización (Borrado/Inserción/Cambio)<br />
u—Deshacer último comando de actualización<br />
U—Deshacer todos los cambios en la línea actual<br />
COMANDOS DEL SHELL.<br />
<br />
:sh———–Invoca un nuevo shell. Al salir continua la edición<br />
:!CmdShell—-Ejecuta un comando del sistema operativo<br />
:r!CmdShell—Ejecuta un comando del S.O. e inserta su salida en la posición del cursor<br />
:!!———–Repite el último comando ejecutado en un shell<br />
OPERACIONES CON ARCHIVOS.<br />
<br />
:w—-Graba las modificaciones efectuadas en el archivo<br />
:w—-archivo Escribe el texto actual en archivo (Sólo si no existía)<br />
:q—-Salir (si no hay cambios)<br />
:q!—Salir (sin grabar)<br />
:wq—Guardar cambios y salir<br />
:x —-Guardar cambios y salir<br />
ZZ—-Guardar cambios y salir<br />
ESTADISTICAS DE ARCHIVO.<br />
<br />
:=——Muestra el número total de líneas del archivo<br />
:.=—–Muestra el número de línea actual<br />
crtl+G–Muestra el nombre del archivo, línea actual, número total de líneas y porcentaje recorrido del archivo.<br />
OPCIONES DE ENTORNO.<br />
<br />
:set opción—–Activa la opción de vi correspondiente<br />
:set noopción—Desactiva la opción de vi correspondiente<br />
<br />
all——-Muestra todas las opciones y sus valores<br />
number—-Muestra numeración de líneas<br />
list——Muestra caracteres de control<br />
ic——–Ignora mayúsculas/minúsculas en las búsquedas<br />
<br />
==sed ==<br />
<br />
'''sed''', stream editor, es una utilidad de edición de texto en modo línea de comandos que permite ejecutar comandos sobre las líneas de uno o varios archivos de entrada línea a línea. El modo de operación es tal que se procesa cada una de las líneas, delimitadas por caracteres de retorno de carro, y se le aplican los comandos especificados en la sintaxis de llamada a sed. A modo de resumen, sed opera del siguiente modo:<br />
<br />
* Lectura de una línea desde el flujo de entrada (las líneas están delimitada por un carácter de salto de línea)<br />
* La línea es procesada en función de los comandos leídos<br />
* Muestra (o no) del resultado en la salida estándar (pantalla)<br />
* Continúa con la línea siguiente<br />
<br />
La '''sintaxis''' es la siguiente:<br />
<br />
'''sed [-opciones] [comando] [<fichero(s)>]'''<br />
<br />
detallando las '''opciones''':<br />
<br />
'''sed [-n [-e comando] [-f script] [-i[.extension]] [l [corte]] rsu] [<comando>] [<fichero(s)>]'''<br />
<br />
* '''-n''', --quiet, --silent<br />
Solicitud implícita para no mostrar el estado de la memoria principal (buffer). En un script la notación se hará de esta manera "*n" (un signo almohadilla seguido del carácter “n”) y se deberá encontrar en la 1ra línea del script.<br />
* '''-e script''', --expresión=script<br />
Permite encadenar varios comandos<br />
* '''-f fichero-script''', '''--file=fichero-script<br />
Lectura de comandos desde el fichero indicado<br />
* '''-i[SUFIJO]''', --in-place[=SUFIJO]<br />
Edita archivos en el lugar. También da la posibilidad de hacer una copia de respaldo añadiendo la extensión (-i.BAK)<br />
* '''-r''', --regexp-extended<br />
Utiliza expresiones regulares extendidas (ERE)<br />
* '''-s''', --separate<br />
Si varios ficheros son ingresados en la entrada, los procesa uno a uno en vez que como uno solo<br />
* '''-u''', --unbuffered<br />
Carga cantidades mínimas de datos desde los ficheros de entrada y libera los almacenamientos temporales de salida con mayor frecuencia<br />
* '''--help'''<br />
Muestra esta ayuda y termina<br />
* '''--version'''<br />
Muestra información acerca de la versión del programa y termina.<br />
<br />
Algunos '''comandos''':<br />
<br />
* '''p''': Imprimir<br />
Ejemplo:<br />
<pre><br />
sed 's/unix/linux/p' file.txt<br />
</pre><br />
El comando p muestra cada una de las líneas sustituidas. Como sed escribe en la salida estándar cada una de las líneas procesadas, las líneas a las que se ha efectuado la sustitución aparecerán 2 veces en la salida<br />
* '''s''': Sustitución<br />
Ejemplo:<br />
<pre><br />
sed 's/original/nuevo/g' archivo.txt<br />
</pre><br />
Sustituye todas las ocurrencias del texto "original" por "nuevo" en archivo.txt. Notar que las expresiones van precedidas por el carácter /<br />
* '''d''': Borrado<br />
Ejemplo:<br />
<pre><br />
sed '1,5d' archivo.txt<br />
</pre><br />
Elimina las líneas 1 a 5 de archivo.txt<br />
<pre><br />
sed '1,/Jack/d' poem.txt<br />
</pre><br />
Elimina desde la línea 1 hasta la aparición del texto "Jack"<br />
* '''i''': Inserción<br />
Ejemplos:<br />
<pre><br />
sed '4 i Si tú me dices ven' archivo.txt<br />
</pre><br />
Inserta antes de la línea 4 de archivo.txt (para insertarlo antes utilizaríamos la opción '''a''' en lugar de '''i''') el texto "Si tú me dices ven"<br />
<pre><br />
sed '/Sysadmin/a Lo dejo todo' archivo.txt<br />
</pre><br />
Añade a continuación de las líneas en las que aparezca el texto "Sysadmin", el texto "Lo dejo todo"<br />
* '''c''': Cambio<br />
<pre><br />
sed '/unix/ c "nuevo texto"' file.txt<br />
</pre><br />
Cambia las líneas que contengan el texto unix por "nuevo texto" en el archivo file.txt<br />
<pre><br />
sed -r '1,7s/[a-z]+/nuevotexto/' file.txt<br />
</pre><br />
Sustituye, comando s, '''entre las líneas 1 a 7''' del archivo file.txt aquellas líneas que verifiquen el patrón de expresión regular, para eso habilitamos las expresiones regulares con '''-r'''. Busca expresiones alfanuméricas en minúsculas, [a-z]+, y sustituye las ocurrencias por "nuevotexto". Como no se utiliza la opción '''-i''', no se modifica el contenido del archivo original<br />
Comando para obtener un listado de los directorios del PATH:<br />
<br />
<pre>ls -la echo `echo $PATH | sed 's/:/ /g'`</pre><br />
<br />
'''Direcciones'''<br />
sed como se ha visto reconoce direcciones a la hora de especificar los comandos de procesamiento. Se pueden especificar de varios modos<br />
* '''numero''': indicando el número de la línea<br />
* '''inicio~paso''': indica las líneas n-ésimas (según el valor de paso), a partir de la línea inicial (según inicio)<br />
* '''/expr_regular/''': indicando las líneas que verifican la expresión regular indicada<br />
Por tanto el uso de expresiones regulares POSIX es común en la definición de comando sed<br />
<br />
== AWK ==<br />
<br />
Awk es un lenguaje de programación utilizado para procesar información en modo texto. Trabaja de modo similar a sed en el sentido que procesa archivos de texto línea por línea, aplicando patrones de búsqueda y ejecutando acciones definidas en el comando.<br />
<br />
La sintaxis principal de awk es:<br />
<br />
'''awk '/patron_busqueda/ {acciones;}' archivo'''<br />
<br />
Donde<br />
* '''patron_busqueda''' (opcional): es una expresión regular que se buscará en cada una de las líneas del archivo. Sino se especifica se procesarán todas las líneas<br />
* '''{acciones;}''': conjunto de acciones, separadas por ;, que representan los comandos a ejecutar en cada línea procesada en el archivo que verifique la condición establecida en el patrón de búsqueda. Por defecto, sino se especifica acción, se imprimirá por defecto la línea entera<br />
<br />
=== Patrón de búsqueda ===<br />
<br />
En esta expresión aplicaremos expresiones regulares para determinar la coincidencia textual<br />
<br />
* Se utilizarán los operadores '''==, <, >, >=, >=, !=''' para expresar comparación directa o literal en la condición<br />
* Se utilizará el operador ~ para indicar comparación de campo mediante el uso de una expresión regular <br />
* En la condición establecida por el patrón de búsqueda pueden utilizarse los operadores '''&&''' (y lógico) y '''||''' (o lógico)<br />
<br />
=== Claúsulas BEGIN y END ===<br />
<br />
Si se usan estas cláusulas la sintaxis es<br />
<br />
'''awk 'BEGIN {acciones;}<br />
/patron_busqueda/ {acciones;}<br />
END {acciones;}' archivo'''<br />
<br />
* La claúsula '''BEGIN''' se ejecuta antes de procesar cualquier línea del archivo<br />
* La claúsula '''END''' se ejecuta tras procesar todas las líneas del archivo<br />
<br />
Su uso más habitual es inicializar variables o ejecutar una acción global de inicio y fin del comando awk<br />
<br />
=== Uso de scripts externos ===<br />
<br />
Para scripts o expresiones complejas con awk es posible utilizar archivos externos en la que definir los comandos y patrones. Para ejecutar awk tomando como entrada un archivo de expresiones awk utilizamos la opción '''-f'''<br />
<br />
<pre><br />
awk -f archivo.awk<br />
</pre><br />
<br />
=== Ejemplos de Uso ===<br />
<br />
* '''Imprimir todas las líneas de un archivo'''<br />
<pre><br />
awk /etc/passwd<br />
</pre><br />
* '''Imprimir las líneas de un archivo según un patrón textual'''<br />
<pre><br />
awk '/root/' /etc/passwd<br />
</pre><br />
En este caso buscaría en las líneas de /etc/passwd aquella que contenga el texto root<br />
* '''Seleccionar las líneas vacías de un archivo'''<br />
<pre><br />
awk '/^$/' archivo<br />
</pre><br />
* '''Contar las líneas de un archivo'''<br />
<pre><br />
awk '{x=x+1};END {print x}' /etc/passwd<br />
</pre><br />
<br />
El texto dentro del archivo se procesa línea por línea, '''RECORDS''' para awk, y dentro de cada línea se identificarán los campos, '''FIELDS''' para awk.<br />
<br />
Utilizamos los siguientes identificadores para hacer referencia a las partes de cada RECORD<br />
* '''$0''': la línea completa<br />
* '''$1, $2, $3...''': FIELDS según su posición, $1, primer FIELD, campo o columna de la línea, por defecto se utiliza como carácter de separación el espacio, o conjunto de espacios. Este valor puede redefinirse en la variable '''FS'''<br />
* '''$NF''': Número de FIELDS de la línea. Muy útil para hacer referencia al último FIELD de la línea<br />
<br />
Otras variables<br />
* '''NR''': Número de RECORDs (líneas)<br />
* '''RS''': Separador de RECORD, por defecto el salto de línea<br />
* '''FS''': Separador de FIELD de entrada<br />
* '''OFS''': Separador de FIELD de salida<br />
* '''CR''': RECORD actual<br />
* '''CF''': FIELD actual<br />
<br />
Más ejemplos:<br />
<br />
* '''Imprimir el primer campo de un archivo'''<br />
<pre><br />
awk '{print $1}' /etc/passwd<br />
</pre><br />
* '''Imprimir el primer campo cuando ese campo verifique una condición de expresión regular'''<br />
<pre><br />
awk '$1 ~ /^r/ {print $1}' /etc/passwd<br />
</pre><br />
* '''Imprimir el primer y quinto campo de un archivo de las líneas que empiecen por r'''<br />
<pre><br />
awk -F: '/^r/ {print $1" "$5}' /etc/passwd<br />
</pre><br />
En este caso entre el $1 y el $5 se ha introducido un " " para insertar un espacio en blanco entre los campos, necesario pues awk no procesa los espacios en la expresión del print. La opción '''-F''' permite redefinir el separador de campo, en este caso a ":" que es el carácter que delimita los campos en cada línea dentro del archivo /etc/passwd.<br />
El comando anterior sería equivalente a<br />
<pre><br />
awk 'BEGIN {FS=":"}<br />
/^r/ {print $1" "$5}' /etc/passwd<br />
</pre><br />
* '''Contar las líneas vacías de un archivo'''<br />
<pre><br />
awk 'BEGIN {x=0}<br />
/^$/ {x=x+1}<br />
END {print "Hay " x " lineas vacias en el archivo"}' /etc/passwd<br />
</pre><br />
Prestar atención a la posición de los '' y a las comillas del mensaje de texto del END<br />
'''Suma de dos números'''<br />
<pre><br />
echo "7 8" | awk '{print $1+$2}'<br />
</pre><br />
'''Raíz cuadrada de un número'''<br />
<pre><br />
echo 10 | awk '{print sqrt($1)}'<br />
</pre><br />
'''Seno de un número'''<br />
<pre><br />
echo "7" | awk '{print sin($1)}'<br />
</pre><br />
'''Ejecutar una suma'''<br />
<pre><br />
echo "1 2 3 4 5" | awk 'BEGIN {suma=0;RS=" "};{suma=suma+$CF};END {print "la suma es " suma}'<br />
</pre><br />
'''Cálculo de las primeras potencias de 2'''<br />
<pre><br />
echo "1 2 3 4 5 6 7 8 9 10" | awk 'BEGIN {RS=" "};{print 2^$CF}'<br />
</pre><br />
'''Producto de varios números'''<br />
<pre><br />
echo -e "1\n3\n5\n8" | awk 'BEGIN {res=1};{res=res'''$CF};END {print res}'<br />
</pre><br />
<br />
== Referencias ==<br />
<br />
'''Vim tips and tricks'''<br />
<br />
https://www.cs.oberlin.edu/~kuperman/help/vim/<br />
<br />
'''Search replace'''<br />
<br />
http://vim.wikia.com/wiki/Search_and_replace<br />
<br />
'''Usos del comando sed'''<br />
<br />
http://www.grymoire.com/Unix/sed.html<br />
<br />
'''Manual sed'''<br />
<br />
http://lowfatlinux.com/linux-sed-manual.html<br />
<br />
'''Ejemplos sed:'''<br />
<br />
http://www.folkstalk.com/2012/01/sed-command-in-unix-examples.html<br />
<br />
'''AWK'''<br />
<br />
https://www.ibm.com/developerworks/library/l-awk1/<br />
<br />
'''Expresiones regulares'''<br />
<br />
https://manuais.iessanclemente.net/index.php/Exmpresions_Regulares_en_Linux<br />
http://www.tutorialspoint.com/unix/unix-regular-expressions.htm<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Entorno_y_herramientas_en_linux&diff=65307Entorno y herramientas en linux2019-01-08T19:31:10Z<p>Javierfp: </p>
<hr />
<div>* [[Información del Sistema]]<br />
* [[Dispositivos]]<br />
* [[Edición de textos]]<br />
* [[Arranque. SysVinit]]<br />
* [[Automatización de tareas]]<br />
* [[Copias de seguridad]]<br />
<br />
[[Linux|Volver]]</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Copias_de_seguridad&diff=65306Copias de seguridad2019-01-08T19:29:20Z<p>Javierfp: Página creada con «La realización de copias de seguridad es uno de los aspectos fundamentales de la administración de sistemas. Siempre existe la posibilidad de que ocurra un desastre o una…»</p>
<hr />
<div>La realización de copias de seguridad es uno de los aspectos fundamentales de la administración de sistemas. Siempre existe la posibilidad de que ocurra un desastre o una pérdida accidental de información (como por ejemplo un comando rm mal escrito), por tanto, independientemente de los niveles de seguridad hardware (como RAID) deben establecerse políticas de copia de seguridad periódica de los datos.<br />
Existen múltiples herramientas de gestión de copias de seguridad sobre Linux, algunas privativas y otras libres. A continuación veremos algunas herramientas estándar, disponibles en cualquier Linux a través de la consola de terminal que nos permitirán realizar esta tarea.<br />
<br />
== Comando tar ==<br />
<br />
Este comando es una utilidad que permite empaquetar o archivar ficheros en un único archivo con extensión .tar. Es por tanto una herramienta que nos permite manejar varios archivos como una única unidad, muy útil por ejemplo para mover archivos por la red o para hacer copias de seguridad del contenido de directorios. Su sintaxis es:<br />
<br />
'''tar [opciones] archivos'''<br />
<br />
Opciones principales:<br />
<br />
* -f: Especifica el fichero que se va a utilizar como archivador<br />
* -c: Indica que se creará el fichero archivador tar<br />
* -C: Especifica directorio de destino en el que se extraerán los contenidos del tar<br />
* -v: Verboso, muestra información por pantalla de la ejecución del comando<br />
* -x: Se utiliza para extraer los ficheros del archivador<br />
* -t: Se utiliza para listar el contenido de un archivador tar<br />
* -p: Conserva los permisos de los ficheros<br />
* -z: Soporte para compresión mediante gzip<br />
* -j: Soporte para compresión mediante bz2<br />
<br />
Es importante a la hora de archivar los ficheros determinar si se usarán rutas absolutas o relativos. Veámoslo con un ejemplo:<br />
<br />
<pre><br />
tar -cvf archivo.tar .<br />
</pre><br />
<br />
Archiva todos los archivos del directorio actual en el fichero archivo.tar, almacenando directamente en él los archivos sin añadir rutas absolutas<br />
<br />
<pre><br />
tar -cvf archivo.tar /home/usuario<br />
</pre><br />
<br />
Archiva todos los archivos del directorio /home/usuario en archivo.tar, manteniendo la información de ruta absoluta.<br />
<br />
La diferencia entre mantener rutas absolutas o no es que a la hora de extraer se crearán los directorios correspondientes en el sistema de archivos destino<br />
<br />
Tras crear un archivador tar suele ser buena idea listar sus contenidos para comprobar que se ha realizado correctamente el comando:<br />
<br />
<pre><br />
tar -tvf archivo.tar<br />
</pre><br />
<br />
Mostraría el listado de las rutas de los archivos en el archivador .tar<br />
<br />
Ejemplo de uso de compresión:<br />
<br />
<pre><br />
tar -cvzf archivo.tar.gz /home/usuario<br />
</pre><br />
<br />
Notad que si usamos la opción -f para especificar el fichero archivador, éste debe de ser la última opción pues requiere a continuación el parámetro que indica el nombre del archivo. Si queremos utilizar el algoritmo de compresión '''bz2 en lugar de zip, usaríamos la opción -j en lugar de -z''':<br />
<br />
<pre><br />
tar -cvjf archivo.tar.bz2 /home/usuario<br />
</pre><br />
<br />
Ejemplo de extracción:<br />
<br />
<pre><br />
tar -xvf archivo.tar<br />
</pre><br />
<br />
Extrae el contenido del archivador archivo.tar en el directorio actual, en el que previamente debemos habernos posicionado con cd.<br />
<br />
Para extraer el contenido de un tar en un directorio especificado utilizamos la opción '''-C''' (el directorio debe existir). Ejemplo:<br />
<br />
<pre><br />
tar -xvf archivo.tar -C /home/usuario/salidatar<br />
</pre><br />
<br />
Ejemplo de extracción y descompresión:<br />
<br />
<pre><br />
tar -xzvf archivo.tar.gz<br />
</pre><br />
<br />
Descomprime y extrae el contenido del archivador archivo.tar.gz en el directorio /home/usuario. Sino se especifica el destino lo extraerá en el directorio actual. Si el archivo estuviese comprimido en .bz2 sustituiríamos la opción -z por -j<br />
<br />
<pre><br />
tar -xjvf archivo.tar.bz2<br />
</pre><br />
<br />
== Comando rsync ==<br />
<br />
rsync es una utilidad muy flexible y potente para realizar transferencias y sincronización de archivos en local y remoto. Tiene la propiedad de que, una vez que se ha realizado una transferencia con rsync, la próxima vez que hagamos otra transferencia relacionada con archivos ya transferidos sólo se sincronizarán los cambios, en caso de que existan respecto a la primera versión transferida. La sintaxis básica es la siguiente:<br />
<br />
'''rsync [opciones] fuente [destino]'''<br />
<br />
dónde el destino puede ser local o un sistema remoto. Para acceso remoto se puede utilizar SSH o bien el propio daemon de rsync.<br />
Sino se especifica el destino entonces se listan los archivos en lugar de copiarlos.<br />
Como siempre, para conocer exactamente las opciones y la sintaxis podéis utilizar el comando man para acceder a las páginas del manual correspondientes al comando:<br />
<br />
'''man rsync'''<br />
<br />
'''Veamos algunos ejemplos de uso:'''<br />
<br />
<pre><br />
rsync -a /home/usuario/dir1/ /home/usuario/dir2<br />
</pre><br />
<br />
La opción -a indica que los archivos son transferidos en "archive mode" lo cual indica que los links y permisos se conservan recursivamente en el destino. Por tanto -a será una opción que usaremos siempre. Es importante que se ponga la última "/" en el directorio origen. Sino se pone se creará un directorio dir1 dentro del destino: /home/usuario/dir2/dir1<br />
<br />
Otras opciones:<br />
* -v: modo "verbose", muestra información sobre lo que hace el comando por pantalla<br />
* -z: comprime los datos durante la transferencia de modo transparente<br />
* --delete: Esta opción conserva los borrados. Por defecto si después de realizar una primera transferencia rsync se elimina un archivo del origen, éste sigue existiendo en el destino. Con esta opción forzamos a que los borrados también se sincronizen<br />
<br />
'''Listado de opciones más comunes:'''<br />
<br />
* -a: Archiva. Es una buena configuración. Es sinonimo que especificar “-DGgloprt”<br />
* -b: Hace una copia de los ficheros, aún estando en el destino. Normalmente no es útil utilizar esta opción, a no ser que se quiera tener copia de cada una de las versiones del fichero.<br />
* -e comando_shell: Usa la shell para crear un la conexión con el sistema remoto. Útil para especificar conexiones ssh, con -e ssh.<br />
* -g: Preserva el grupo de los ficheros que van a ser replicados. Importante para los backups.<br />
* -H: Preserva los “hard-links”. Esta opción relentiza el copiado, pero es muy recomendable.<br />
* -l: Copia los “symlinks” como “symlinks”. Sin esta opción marcada, un link simbólico sería respaldado como un fichero.<br />
* -n: Dry run ( Ejecución Seca ): Lista los ficheros que van a ser transferidos, pero no hace el respaldo.<br />
* -o: Preserva el usuario posesor de los ficheros que van a ser replicados. Importante.<br />
* -p: Preserva los permisos de los ficheros. Importante.<br />
* -r: Activa la recursividad. Para incluir todos los subdirectorios de una carpeta.<br />
* --rsh='ssh': Utiliza SSH par la transmisión de datos. Es recomendable ya que sinó usa el protocolo inseguro rsh. Se usa cuando el servidor remoto tiene instalado SSH, evidentemente.<br />
* -t: Preserva las fechas de modificación de cada fichero.<br />
* -v: Hace una de los ficheros que son transferidos.<br />
* -vv: Igual que -v, pero además muestra los ficheros que no van a ser copiados.<br />
* -vvv: Igual que -vv, pero también imprime información de debug de rsync<br />
* -z: Activa la compresión. Importante si hacemos respaldos a través de Internet.<br />
<br />
Copiado remoto con ssh:<br />
<br />
<pre><br />
rsync -avz -e ssh /home/usuario/ usuario@servidor.com:/home/usuario<br />
</pre><br />
<br />
Copia archivos locales de /home/usuario a una ubicación remota utilizando ssh en el servidor remoto "servidor.com" con el usuario "usuario". Será necesario que esté instalado un servidor ssh en el servidor remoto, como openssh.<br />
<br />
<pre><br />
rsync -avz -e ssh usuario@servidor.com:/home/usuario /home/usuario<br />
</pre><br />
<br />
Es la inversa de la anterior, se toma como fuente el sistema remoto y se copia en el sistema local<br />
<br />
También se puede hacer copias remotas utilizando el propio daemon rsync, sin necesidad de utilizar ssh.<br />
<br />
== Referencias ==<br />
<br />
'''Rsync y SSH'''<br />
<br />
http://troy.jdmz.net/rsync/index.html<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Automatizaci%C3%B3n_de_tareas&diff=65305Automatización de tareas2019-01-08T19:24:36Z<p>Javierfp: /* Automatizando Tareas con cron */</p>
<hr />
<div>== Automatizando Tareas con cron ==<br />
<br />
cron es una utilidad estándar en Linux utilizada para automatizar tareas que deben ejecutarse periódicamente. En todos los Sistemas Linux se ejecuta un daemon, crond, que se activa una vez por minuto y ejecuta las tareas que tenga pendientes. De este modo mediante un fichero de texto, crontab (tabla de tareas cron), se pueden automatizar tareas especificando su período.<br />
La idea es que en un fichero de definición de tareas, crontab, se incluya en cada línea de ese archivo la tarea a ejecutar, como un comando de shell, y el instante temporal en que se va a lanzar.<br />
El comando que permite manejar esta utilidad es '''crontab''', cuyas principales opciones son:<br />
<br />
* -e: Edita la tabla cron del usuario actual<br />
* -l: Lista las tareas cron del usuario actual<br />
* -u: Especifica el usuario del que queremos administrar su crontab (solo root puede invocar esta opción)<br />
* -r: Elimina la tabla de cron del usuario<br />
<br />
También se pueden definir tareas periódicas editando, como root, directamente el archivo '''/etc/crontab'''. Otra alternativa es utilizar los directorio '''/etc/cron.daily''' (ejecución diaria), '''/etc/cron.weekly''' (semanal) y '''/etc/cron.monthly''' (mensual), dentro ode los cuales se ubicarán scripts que deberán ser ejecutados con la periodicidad indicada y según lo establecido en '''/etc/crontab'''<br />
<br />
=== Sintaxis de crontab ===<br />
<br />
El formato de configuración de cron es muy sencillo:<br />
<br />
* El símbolo almohadilla «*» es un comentario, todo lo que se encuentre después de ese carácter no será ejecutado por cron.<br />
* El momento de ejecución se especifica de acuerdo con la siguiente tabla:<br />
** Minutos: (0-59)<br />
** Horas: (0-23)<br />
** Días: (1-31)<br />
** Mes: (1-12)<br />
** Día de la semana: (0-6), siendo 1=lunes, 2=martes,... 6=sábado y 0=domingo (a veces también 7=domingo)<br />
<br />
algunos sistemas soportan la especificación de divisores del tiempo a la hora de definir la tarea. Por ejemplo:<br />
<br />
<pre><br />
/2: cada 2 minutos<br />
/10: cada 10 minutos<br />
</pre><br />
<br />
=== Ejemplos ===<br />
<br />
'''30 10 ''' ''' 1 /usr/bin/who >> /home/quien.tex'''<br />
<br />
Ejecuta la orden who todos los lunes a las 10:30 (campo primero, minutos, 30, campo segundo, hora, 10, último campo, día de la semana, 1, lunes) y guarda la salida en el fichero quien.tex<br />
<br />
'''30 21 ''' ''' 6 /sbin/shutdown -h now'''<br />
<br />
Ejecuta un apagado de la máquina todos los sábados a las 21:30<br />
<br />
'''0 12 ''' ''' ''' find /tmp -ls -exec rm -r {} \;'''<br />
<br />
Elimina todos los archivos temporales en /tmp todos los días a las 12 del mediodía<br />
<br />
=== Nota ===<br />
<br />
Cada vez que se ejecuta una tarea del cron se envía un mail al usuario que ejecuta la tarea. Para deshabilitar esta característica podemos añadir '''>/dev/null 2>&1''' al final de la tarea o bien añadir en el archivo del cron la variable '''MAILTO=""'''<br />
<br />
== El comando at ==<br />
<br />
Este comando permite ejecutar una tarea programada para un instante de tiempo dado. Al contrario que cron, no se utiliza para programar de modo persistente las tareas, sino que está más indicada para tareas puntuales que deben de ser ejecutadas con cierta demora. Veamos un ejemplo<br />
<br />
<pre><br />
at 12:00<br />
warning: commands will be executed using /bin/sh<br />
at> reboot<br />
at> <EOT><br />
job 2 at Tue Apr 19 12:00:00 2016<br />
</pre><br />
<br />
Escribimos el comando, at 12:00, en este caso indicando que la tarea se ejecutará a las 12:00, a continuación entramos en un modo edición interactivo, introducimos el comando a realizar y cerramos con CTRL+D, tras lo cual se creará la tarea con un id asociado, en este caso el id 2<br />
<br />
Para ver la cola de tareas de at<br />
<br />
<pre><br />
atq<br />
</pre><br />
<br />
Eliminar una tarea de at<br />
<br />
<pre><br />
atrm 2<br />
</pre><br />
<br />
Esta eliminaría la tarea con número 2<br />
<br />
== Referencias ==<br />
<br />
'''Unix cron'''<br />
<br />
http://es.wikipedia.org/wiki/Cron_%28Unix%29<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Rc5.d.PNG&diff=65293Archivo:Rc5.d.PNG2019-01-08T18:50:17Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:ChuletaVim-simple.jpg&diff=65290Archivo:ChuletaVim-simple.jpg2019-01-08T18:42:49Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Dispositivos&diff=65287Dispositivos2019-01-08T18:22:50Z<p>Javierfp: Página creada con «En Linux los dispostivos hardware son representados mediante abstracciones a través del Sistema de Archivos. De este modo los dispositivos pueden ser manejados a través d…»</p>
<hr />
<div>En Linux los dispostivos hardware son representados mediante abstracciones a través del Sistema de Archivos. De este modo los dispositivos pueden ser manejados a través del concepto de archivo y directorio. Sin embargo, debido a las propias características heterogéneas del dispositivo y a la necesidad de los controladores de dispositivo, que permitan la comunicación con el mismo a través del Sistema Operativo, es necesario un soporte de configuración adicional<br />
<br />
== Características ==<br />
<br />
A la hora de representar un dispositivo en Linux se utiliza información asociada al mismo que puede ser accedida, como en el caso de archivos y directorios, a través del i-nodo correspondiente. Veamos un ejemplo:<br />
<br />
<pre><br />
ls -la /dev/sda1<br />
brw-rw---- 1 root disk 8, 1 Xuñ 3 09:00 /dev/sda1<br />
</pre><br />
<br />
En el comando anterior se muestra información del archivo de dispositivo asociado a la '''primera partición del primer disco duro (sda1)''' y en esa salida podemos observar<br />
<br />
* '''El Dispositivos es de tipo bloques (b)'''<br />
* '''Permisos y propietario'''<br />
* '''disk''': se trata de un disco<br />
* '''Los números minor y major de dispositivo (8, 1)''': '''Major number''': identifica el driver que maneja el dispositivo, '''Minor number''': permite al driver identificar un dispositivo concreto entre varios controlados por el mismo driver<br />
<br />
== Creación de archivos de dispositivos ==<br />
<br />
Durante el arranque se utilizan sistemas de creación automática de archivos de dispositivo en el kernel por parte del servicio '''udev''', que genera automáticamente los archivos de dispositivos, a través de los cuales el kernel se comunica con éstos. Si por algún motivo no se crean, o somos incapaces de acceder a algún dispositivo externo podemos utilizar el siguiente procedimiento para crear manualmente los archivos de dispositivo asociados.<br />
<br />
Puede utilizarse el comando '''mknod''' para la creación de archivos de dispositivos en el Sistema de Archivos, es necesario pasar en el comando los números major y minor del dispositivo, esto quiere decir que es necesario conocer información del driver que los maneja. La sintaxis del comando es: '''mknod [opciones] nombre tipo [major minor]'''. Veamos un ejemplo:<br />
<br />
<pre><br />
mknod /dev/sda b 3 0<br />
</pre><br />
<br />
Crea un archivo de dispositivo para el dispositivo '''/dev/sda''' con números major y minor 3 y 0 respectivamente. Para conocer los números major y minor de un dispositivo dado podemos usar el comando '''stat''' del siguiete modo (en este ejemplo para el dispositivo /dev/sda)<br />
<br />
<pre><br />
stat -c 'major: %t minor: %T' /dev/sda<br />
</pre><br />
<br />
Este comando puede resultar útil para determinar los major y minor utilizados por un dispositivo existente como pista para crear archivos de dispositivos nuevo<br />
<br />
El script '''makedev''' también permite la creación de archivos de dispositivo de un modo automático, sin necesidad de especificar los números major y minor, sin embargo no siempre puede ser utilizado<br />
<br />
<pre><br />
cd /dev<br />
./MAKEDEV -v sda<br />
</pre><br />
<br />
Otro posible uso que justique la creación de archivos de dispositivo es la creción de un '''named pipe''', canalización con nombre, para la intercomunicación entre procesos. Uno de los procesos puede escribir en la canalización y otro puede leer de ella.<br />
<br />
== Gestion dinámica de dispositivos ==<br />
<br />
Durante el arranque del sistema es necesario que ciertos archivos de dispositivos se creen automáticamente. El kernel tiene ciertos controladores de dispositivo '''estáticamente integrados''', pero otros son cargados como módulos y, por tanto, deben ser gestionados de un '''modo dinámico''' durante el arranque del sistema.<br />
<br />
En la actualidad el sistema más utilizado para la gestión dinámica de dispositivos durante el arranque es '''udev''', cuyas características principales son<br />
<br />
* '''Opera en modo de usuario'''<br />
* '''Permite personalizar el nombre de dispositivo''': esta característica es útil para gestionar la conexión de dispositivos en caliente<br />
<br />
== Comandos útiles para ver información de dispositivos ==<br />
<br />
=== blkid ===<br />
<br />
Muestra información de los dispositivos de bloques del sistema<br />
<br />
=== lsblk ===<br />
<br />
Muestra un árbol con los dispositivos principales de almacenamiento y sus particiones<br />
<br />
=== lshw -class storage ===<br />
<br />
El comando lshw muestra información genérica sobre el hardware. Con la opción -class storage filtra aquella información correspondiente a los dispositivos de almacenamiento<br />
<br />
== Referencias ==<br />
<br />
'''Udev'''<br />
http://www.escomposlinux.org/lfs-es/lfs-es-SVN/chapter07/udev.html<br />
https://wiki.archlinux.org/index.php/udev<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Informaci%C3%B3n_del_Sistema&diff=65286Información del Sistema2019-01-08T18:18:04Z<p>Javierfp: /* El comando time */</p>
<hr />
<div>== Logs ==<br />
<br />
Los logs, o registros, son archivos de texto, por lo general con extensión .log, en los que el sistema operativo vuelca información de la ejecución de los procesos. Mediante el análisis de su contenido, podemos recopilar información sobre las condiciones de ejecución, o error, de un determinado proceso. Linux utiliza ampliamente un sistema de gestión de logs conocido como '''syslog''', o alguna de sus variantes más avanzadas, como el caso de '''rsyslog''' en Ubuntu. Según la importancia del mensaje, lo que se denomina '''severidad''', se pueden tomar acciones en respuesta al evento que ha originado el log. Por ejemplo, un error '''crítico del kernel''', será identificado como originado por el facility '''kernel''' y nivel de severity '''critical'''. El administrador, en respuesta, podría configurar acciones que van desde la propia escritura en un archivo de texto .log determinado, hasta el envío de un mail de aviso a su cuenta de correo.<br />
<br />
Los archivos de texto asociados a los logs suelen ubicarse en el directorio '''/var/log''', el cual suele estar estructurado según la naturaleza de los procesos que originan la información<br />
<br />
== Comando strace ==<br />
<br />
Este es un comando muy útil para revisar las condiciones exhaustivas de ejecución de un programa. Básicamente lo que hace es un volcado de la '''traza de ejecución''' de un proceso (ahí se muestra información de bajo nivel sobre el estado de la CPU, interrupciones, etc.).<br />
<br />
El volumen de información generado es enorme, ya que se muestra información de las instrucciones ejecutadas por el proceso. Este tipo de información es utilizada habitualmente por los desarrolladores durante los procesos de depuración, '''debug''', de sus programas.<br />
<br />
Ejemplo:<br />
<pre><br />
strace /usr/bin/who<br />
</pre><br />
<br />
== Ver información sobre hardware ==<br />
<br />
=== Comandos lsxxx ===<br />
<br />
Comandos como '''lshw, lspci, lsusb, lscpu''' permiten ver información relativa a los dispositivos hardware del Sistema. Ejemplo:<br />
<br />
<pre><br />
lshw -class network<br />
</pre><br />
<br />
mostraría los dispositivos físicos de red. Otras clases de dispositivos que se pueden consultar con la opción '''-class''' son:<br />
* '''bus'''<br />
* '''multimedia'''<br />
* '''processor'''<br />
* '''bridge'''<br />
* '''storage'''<br />
* '''display'''<br />
* '''memory'''<br />
<br />
Este comando '''lshw''' es muy útil, ya que permite ver información de todo tipo de hardware del sistema. Para ver una descripción compacta del hardware y la clase correspondiente a cada dispositivo ejecutamos:<br />
<br />
<pre><br />
lshw -short<br />
</pre><br />
<br />
También es posible visualizar información relativa a los dispositivos hardware con el comando ls, en los directorios virtuales del sistema que incorporan información relativa a los dispositivos. Por ejemplo:<br />
<br />
<pre><br />
ls -d /sys/class/net/eth'''<br />
</pre><br />
<br />
mostraría los dispositivos de red Ethernet<br />
<br />
=== Comando dmidecode ===<br />
<br />
Un comando realmente potente que muestra mucha información. Obtiene la información a través de la especificación '''SMBIOS''', que permite leer información a través de estructuras de datos que almacenan la información del '''BIOS'''<br />
<br />
<pre><br />
dmidecode -q<br />
</pre><br />
<br />
Muestra información global del sistema, incluyendo todos los elementos<br />
<br />
<pre><br />
dmidecode --type baseboard<br />
</pre><br />
<br />
Muestra información sobre la placa base. Otros valores posibles para el parámetro '''type''':<br />
<br />
* '''bios'''<br />
* '''system'''<br />
* '''processor'''<br />
* '''chassis'''<br />
* '''memory'''<br />
* '''cache'''<br />
* '''connector'''<br />
* '''slot'''<br />
<br />
=== Comando dmesg ===<br />
<br />
El comando dmesg permite visualizar los mensajes generados por el kernel en el arranque del sistema. Para verlos podemos utilizar un filtro con grep. Por ejemplo<br />
<br />
<pre><br />
dmesg | grep "eth"<br />
</pre><br />
<br />
=== Comando hardinfo ===<br />
<br />
Muy útil, admite también la posibilidad de ejecutar benchmark de rendimiento. Podemos instalarlo con<br />
<br />
<pre><br />
apt-get install hardinfo<br />
</pre><br />
<br />
Las opciones más interesantes<br />
<br />
* '''--help''': muestra la ayuda del comando<br />
* '''-m''': permite cargar módulos para configurar su funcionamiento<br />
* '''-l''': lista los módulos disponibles<br />
* '''-a''': aplica automáticamente dependencias entre módulos<br />
<br />
El siguiente comando mostraría información de dispositivos:<br />
<br />
<pre><br />
hardinfo -m devices.so -a<br />
</pre><br />
<br />
Con el siguiente comando veríamos información de dispositivos de red<br />
<br />
<pre><br />
hardinfo -m network.so -a<br />
</pre><br />
<br />
=== Comando hdparm ===<br />
<br />
Útil para visualizar información sobre dispositivos de almacenamiento secundario<br />
<br />
<pre><br />
sudo hdparm -I /dev/sda<br />
</pre><br />
<br />
=== Archivos en el directorio /proc ===<br />
<br />
En este directorio virtual el kernel vuelca información sobre los procesos y recursos del sistema. Algunos archivos que contienen información útiles:<br />
<br />
* '''/proc/cpuinfo'''<br />
* '''/proc/meminfo'''<br />
* '''/proc/version'''<br />
* '''/proc/partitions'''<br />
<br />
...y muchos más, para verlos podemos hacer un:<br />
<br />
<pre><br />
for f in /proc/'''; do if [ -f $f ];then echo `basename $f`;fi;done<br />
</pre><br />
<br />
Dentro del directorio /proc hay subdirectorios con nombres numéricos correspondientes a los PID de los procesos en ejecución. Dentro de cada uno de esos subdirectorios se almacena información de cada uno de los procesos.<br />
<br />
=== El paquete sysstat ===<br />
<br />
En este paquete encontramos utilidades de comandos como '''mpstat''', que muestra información sobre la CPU e '''iostat''', Entrada y Salida. También disponemos, sin necesidad de instalar el paquete sysstat, de la utilidad '''vmstat''' que muestra información acerca de la Memoria Virtual<br />
<br />
=== El comando time ===<br />
<br />
El comando time sirve para "cronometrar" las tareas que se ejecutan bajo su control. Por ejemplo<br />
<br />
<pre><br />
time for a in {1..1000000};do continue;done<br />
</pre><br />
<br />
Mostraría las estadísticas de tiempos de ejecución del ciclo iterativo del bucle for indicado<br />
<br />
[[Entorno y herramientas en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Linux&diff=65282Linux2019-01-08T18:03:39Z<p>Javierfp: /* Básicos */</p>
<hr />
<div>== Básicos == <br />
* [http://informatica.iessanclemente.net/wikilinux/index.php/Portada Curso sobre linux do CEFORE 2007]. Curso impartido por Carlos Carrión e Antonio de Andrés.<br />
* [[Curso Platega 08-09: Sistema operativo GNU-LINUX: UBUNTU 8.10]]<br />
* [[Curso Platega: Servizos de rede e deseño dunha infraestrutura de dominio con GNU/Linux]]. Edición 2014<br />
* '''[[Curso Platega: Administración de dominios en redes locais con GNU/Linux]]. Edición 2017/2018'''<br />
* [[Curso Platega: Ubuntu Desktop. Un sistema dual (MS Windows / GNU/Linux)]] '''Edición 2013'''<br />
* [[OpenSuse]]<br />
* [[Zentyal]]<br />
* [[Instalación de Servidor Linux]]<br />
* [[Comandos básicos de xestión e administración en linux]].<br />
* [[Entorno y herramientas en linux]].<br />
* [[Programación Bash]].<br />
* [[Xestores de arranque en linux]].<br />
* [[Acceso remoto]].<br />
* [[Instalación sobre RAID e LVM]]<br />
* [[Instalación e Compilación de software]]<br />
* [[Gestión del Sistema con Systemd]]<br />
* [[Administración de Dispositivos y Sistemas de Archivos en GNU/Linux]]<br />
* [[Monitorización]]<br />
<br />
== Sistemas Operativos ''Singulares'' ==<br />
* [[LTSP]] (''Linux Terminal Server Project'')<br />
* [[Mediacenter en Linux]]<br />
* [[Tina POS]] - ''Terminal Punto de Venta''<br />
* [[Live USB]] - ''Crear unha Live USB''<br />
<br />
== Enlaces Interesantes ==<br />
* [http://distrowatch.com/ Comparativa das distribucións linux].<br />
* [http://www.ispconfig.org/documentation.htm Instalando o servidor perfecto en Linux].<br />
* [http://learnlinux.tsf.org.za/courses/web-courses.html Materiais Libres e Abertos para o ensino de Linux].<br />
* [http://lachozadeltiotux.blogspot.com/2007/07/como-recuperar-contrasea-del-root-en.html Recuperar o contrasinal esquecido de root en Linux]</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Gesti%C3%B3n_de_Dispositivos_de_Almacenamiento&diff=65281Gestión de Dispositivos de Almacenamiento2019-01-08T17:53:04Z<p>Javierfp: </p>
<hr />
<div>== Particionado ==<br />
<br />
El primer paso para la creación de sistemas de archivos es la preparación de los dispositivos sobre los que se desplegarán los mismos.<br />
<br />
Entendemos por dispositivo todo aquel soporte de almacenamiento de datos compatible con el kernel de Linux. Empezaremos nuestro recorrido partiendo de la base de que existe un dispositivo conectado a la máquina listo para ser utilizado. Podría tratarse, por ejemplo, de alguno de los siguientes:<br />
<br />
# Disco virtual “vacío” conectado a una máquina virtual<br />
# Archivo en un sistema de archivos existente sobre el cual podríamos crear un dispositivo de bloques virtual<br />
# Volumen de almacenamiento lógico LVM<br />
# Volumen constituido por un array de discos de tipo RAID<br />
<br />
para las opciones 3 y 4 necesitaríamos conocer las herramientas de gestión correspondientes, por ejemplo para gestionar un RAID software podríamos utilizar mdadm, y para LVM las versiones modernas de GNU/Linux disponen de herramientas para ello. Sin embargo, vamos a centrarnos en una de las dos primeras, 1 y 2, ya que más adelante veremos aspectos relacionados con RAID y gestión lógica de volúmenes al hablar del sistema de archivos ZFS.<br />
<br />
A partir de ahora nos referiremos al sistema de archivos como '''SA'''<br />
<br />
== Utilizando como base para el SA un disco duro virtual ==<br />
<br />
Esta es la opción más sencilla y habitual, conectar un dispositivo de almacenamiento a nuestro maquina que utilizaremos como base para la creación de particiones y del SA.<br />
<br />
El procedimiento consiste en, desde el panel de gestión de nuestra máquina virtual (en Virtualbox o virt-manager) conectar un nuevo dispositivo a la máquina virtual.<br />
<br />
Una vez arrancado el sistema nuestro dispositivo será representado por el kernel como un dispositivo especial de bloques en /dev, como por ejemplo '''/dev/sdb o /dev/sdc'''<br />
<br />
Para ver los dispositivos de bloques en uso podemos ejecutar el comando<br />
<br />
<pre>lsblk</pre><br />
<br />
<br />
La salida de este comando mostrará los dispositivos de bloques (es decir dispositivos de almacenamiento) disponibles en el sistema y, en caso de estar divididos en particiones, las correspondientes particiones)<br />
<br />
== Utilizando como base para el SA un archivo en un SA existente ==<br />
<br />
Otra opción muy cómoda y nada invasiva con un sistema operativo existente es la utilización de un archivo como base para la creación de un dispositivo de bloques virtual sobre el que crearemos nuestro SA<br />
<br />
=== Creación de un dispositivo de bloques virtual sobre un archivo ===<br />
<br />
Comenzamos creando el archivo. Siempre como usuario root ejecutamos los comandos:<br />
<br />
<pre>dd if=/dev/zero of=./fsraw bs=1M count=10000</pre><br />
<br />
<br />
el comando anterior crea un archivo de nombre '''fsraw''', en el diretorio de trabajo de 10GB de capacidad (count=10000 bloques de bs=1Mega byte de tamaño)<br />
<br />
<br />
En este punto ya podríamos crear el SA directamente sobre el archivo anterior, sin embargo vamos a ejecutar un paso adicional consistente en la creación de un dispositivo de bloques asociado al archivo, para a continuación crear el SA sobre ese dispositivo.<br />
<br />
<br />
Ejecutamos el comando:<br />
<br />
<br />
<pre>losetup</pre><br />
<br />
<br />
Este comando, que debería mostrar una salida vacía, muestra los dispositivos '''/dev/loopX''' (que van desde loop0 hasta loop8) que están siendo utilizados. Suponiendo que '''/dev/loop0''' no está siendo utilizado, en este caso no deberíamos ver ese dispositivo listado en la salida del comando '''losetup''', vamos a utilizarlo como dispositivo de bloques asociado al archivo '''fsraw''' creando con anterioridad. La opción -P permite definir particiones dentro del dispositivo de bloques<br />
<br />
<br />
Para ello ejecutamos:<br />
<br />
<br />
<pre>losetup -P /dev/loop0 ./fsraw</pre><br />
<br />
<br />
Tras la ejecución de los pasos anteriores disponemos del dispositivo de bloques '''/dev/loop0''' como base para continuar con los procedimientos que siguen. Si volvemos a ejecutar el comando anterior<br />
<br />
<br />
<pre>losetup</pre><br />
<br />
<br />
veremos como ahora sí aparece el dispositivo '''/dev/loop0''' en el listado<br />
<br />
<br />
Una vez dispongamos del dispositivo procederemos a crear las particiones necesarias para albergar los SA<br />
<br />
En el siguiente vídeo puede verse el proceso de creación del dispositivo virtual de bloques<br />
<br />
[[Image:loop.png|link=https://asciinema.org/a/A7vO7fjtspxoAwnOBGhMqtDlE]]<br />
<br />
''Creación de dispositivo virtual de bloques a partir de archivo''<br />
<br />
=== Creación de las particiones con fdisk ===<br />
<br />
fdisk es una herramienta de gestión de particiones para dispositivos de bloques basados en el formato MBR (o tipo d.o.s.), si queremos utilizar un formato de particionado basado en GPT necesitaríamos utilizar otra herramienta, como '''cfdisk''' o '''gdisk'''.<br />
<br />
Usaremos esta herramienta para crear las particiones en el dispositivo.<br />
<br />
Supongamos que disponemos de un dispositivo '''/dev/sdb''' (en caso de utilizar /dev/loop0 sustituirlo por éste en los comandos correspondientes).<br />
<br />
Vamos ahora a abrir una terminal. Una vez en ella, como usuario root, para ello escribimos el comando:<br />
<br />
<pre>su -</pre><br />
<br />
'''NOTA''': En caso de no tener habilitado el usuario root (algo habitual en Ubuntu) ejecutamos el comando<br />
<br />
<pre>sudo -i</pre><br />
<br />
Una vez en la sesión de root ejecutamos a continuación el comando<br />
<br />
<pre>fdisk</pre><br />
<br />
La ejecución del comando nos mostrará un listado con las opciones de uso más importantes. '''Este comando sirve para crear y gestionar particiciones de un dispositivo''' de almacenamiento. Se utiliza en reemplazo del comando '''parted''' que sirve para gestionar las particiones de un disco duro. '''Con fdisk podemos gestionar las particiones de un modo más cómodo y menos propenso a errores que parted'''<br />
<br />
Ejecutad el comando<br />
<br />
<pre>fdisk -l</pre><br />
<br />
<br />
para ver un listado de los dispositivos y particiones en él. <br />
<br />
'''IMPORTANTE''': Identificad cual de los dispositivos corresponden con el disco que habéis insertado para la práctica (en nuestro caso '''/dev/sdb o /dev/loop0), '''es importante comprobar siempre esto para evitar equivocaciones y acciones potencialmente destructivas)<br />
<br />
Para la identificación propuesta podemos utilizar el comando<br />
<br />
<pre>lsblk</pre><br />
<br />
<br />
el cual nos muestra una visualización en forma de árbol de los dispositivos de bloques, además de información adicional sobre los mismos, como el espacio disponible, los números '''MAJ''' ('''major)''' y '''MIN''' ('''minor)''' del dispositivo, el tipo y el punto de montaje<br />
<br />
Vamos a ejecutar el comando para el disco que hemos conectado a la máquina (también puede hacerse utilizando el dispositivo de bloques /dev/loop0):<br />
<br />
<pre>fdisk /dev/sdb</pre><br />
<br />
<br />
Ahora entrará en modo interactivo para recibir vuestras órdenes. Antes de nada invocad la orden de ayuda ('''pulsando m''')<br />
<br />
A continuación os mostrará las posibles acciones y su uso. Guiándoos por las opciones que aparecen en el listado, realizad los siguientes pasos: (Adjuntad capturas de pantalla)<br />
<br />
# ''Imprimir por pantalla la tabla de particiones el disco''<br />
# ''Eliminad la partición anteriormente creada''<br />
# ''Cread una nueva partición de la mitad de tamaño del disco''<br />
# ''Crea otra partición con el espacio restante''<br />
# ''Establecer el código identificador del sistema de archivos que va a albergar la partición (ver nota más abajo)''<br />
# ''Verifica la tabla de particiones''<br />
# ''Imprime de nuevo la tabla de particiones''<br />
# ''Guarda los cambios en disco y sal (Sino se ejecuta este paso no guardará los cambios)''<br />
<br />
<br />
Indicando el número de alguna de las acciones anteriores entramos en la funcionalidad correspondiente de fdisk, el cual nos asistirá con mensajes de texto e indicaciones de como completar la tarea seleccionada. <br />
<br />
'''IMPORTANTE''': '''Es necesario establecer el identificador del sistema de archivos en la partición''' para luego poder crear el sistema de archivos correspondiente. fdisk utiliza para eso la opción '''t.''' Por tanto, si por ejemplo vamos a crear un sistema de archivos NTFS en una partición deberemos previamente establecer el código identificador del sistema de archivos con la opción t de fdisk, en este caso el código sería '''7.''' Para ver los códigos de sistemas de archivos podemos utilizar la opción '''l''' de fdisk.<br />
<br />
En el siguiente vídeo puede verse como crear particiones en un dispositivo utilizando la utilidad fdisk<br />
<br />
[[Image:fdisk.png|link=https://asciinema.org/a/Kuw7ZHs0pGchjWecYkFG416G3]]<br />
<br />
''Particiones con fdisk''<br />
<br />
== Creación de particiones con cfdisk ==<br />
<br />
El comando fdisk anterior permite gestionar las particiones de discos MBR. Existe otra herramienta, que además dispone de una interfaz ncurses (en modo texto pero con interfaz más utilizable), que soporta las opciones de creación del comando fdisk y permite también crear particiones en discos de formato GPT. Se trata de la utilidad '''cfdisk'''<br />
<br />
El siguiente comando permite definir y gestionar particiones con la herramienta cfdisk. Siempre como root:<br />
<br />
<pre>cfdisk /dev/sdb</pre><br />
<br />
En el siguiente vídeo puede verse como crear particiones en un dispositivo utilizando la utilidad cfdisk<br />
<br />
[[Image:cfdisk.png|link=https://asciinema.org/a/mK664zXCWfo0JaiQyWNGe0AF4]]<br />
<br />
''Particiones con cfdisk''<br />
<br />
== El comando sfdisk ==<br />
<br />
El comando sfdisk se utiliza para comprobar la configuración de particiones de un dispositivo de bloques. Un uso muy común de este comando es copiar a un archivo de texto la tabla de particiones de un dipositivo. Ejecutemos:<br />
<br />
<pre>sfdisk -l /dev/sdb</pre><br />
<br />
<br />
El comando anterior lista todas las particiones del dispositivo /dev/sdb<br />
<br />
<br />
El comando:<br />
<br />
<br />
<pre>sfdisk -l /dev/sda > /tmp/partable</pre><br />
<br />
<br />
Escribe la configuración de la tabla de particiones a un archivo. Este archivo puede ser utilizado luego para recuperar la información de la tabla de particiones<br />
<br />
Otro uso muy interesante es poder copiar tablas de particiones de unos dispositivos a otros, por ejemplo:<br />
<br />
<br />
<pre>sfdisk -d /dev/sda | sfdisk /dev/sdb</pre><br />
<br />
<br />
copiará la tabla de particiones del dispositivo /dev/sda en /dev/sdb<br />
<br />
Veamos el proceso en el siguiente vídeo<br />
<br />
[[Image:sfdisk.png|link=https://asciinema.org/a/A7vO7fjtspxoAwnOBGhMqtDlE]]<br />
<br />
''Copiar tabla de Particiones con sfdisk''<br />
<br />
<br />
[[Administración de Dispositivos y Sistemas de Archivos en GNU/Linux|Volver]]<br />
<br />
JavierFP 18:31 12 nov 2018 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Chmod_tabla.png&diff=65273Archivo:Chmod tabla.png2019-01-08T17:37:59Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Primeros_pasos_con_la_shell._Comandos_b%C3%A1sicos&diff=65270Primeros pasos con la shell. Comandos básicos2019-01-08T17:26:48Z<p>Javierfp: /* Referencias */</p>
<hr />
<div>= Primeros pasos con la shell =<br />
<br />
La shell, o intérprete de comandos, es la herramienta más simple y flexible de administración de un Sistema Linux. Como intérprete de comandos el modelo de trabajo es interactivo y consiste en un programa, la shell, que se encarga de procesar los comandos que el usuario teclea y de ofrecer las salidas correspondientes a las peticiones efectuadas por el mismo.<br />
Existen varios tipos de shell, con diferente soporte a comandos estándar y comandos específicos. En los Sistemas Linux actuales la shell más utilizada es '''bash''' (Bourne Shell Again), la cual suele estar en el directorio /bin (/bin/bash), aunque existen otros tipos de shell (como sh, zsh, etc.).<br />
Asociadas a las shell existe la posibilidad de creación de programas (scripts) que ejecutan automáticamente, o mediante invocación explícita, una secuencia de comandos de la shell que juntos realizan una tarea del sistema concreta, como por ejemplo hacer una copia de seguridad, enviar un correo automáticamente, descargar actualizaciones, etc. La programación de scripts y su mantenimiento es una tarea administrativa importante pues éstos constituyen una potente herramienta de administración del sistema a la que debemos sacarle partido.<br />
<br />
== Sintaxis básica de la shell ==<br />
<br />
'''comando [opciones] [parámetros] [&]'''<br />
<br />
Las '''opciones''' indican al comando el modo de funcionamiento<br />
Los '''parámetros''' son los datos de entrada sobre los que opera el comando<br />
El carácter '''&''' al final indica, si se especifica, que el comando se ejecuta en segundo plano, es decir, se retomará inmediatamente el prompt de la shell, para seguir introduciendo más comandos, pero el proceso invocado por el comando seguirá en ejecución en "segundo plano"<br />
<br />
'''NOTA:''' Los corchetes [] indican opcionalidad, es decir, todo aquello que encierran indica que, en la sintaxis del comando, ese elemento es opcional, pudiendo ser especificado o no.<br />
<br />
Ejemplo: chmod -R 777 ./archivos<br />
<br />
_Comando_: chmod (cambio de permisos de un archivo)<br />
_Opciónes_: -R (indica cambio recursivo en componentes anidados, si es un directorio)<br />
_Parámetros_: 777 ./archivos (777, máscara de permisos y ./archivos el archivo o directorio sobre el que cambiamos permisos)<br />
<br />
'''NOTA''': "Atajos de teclado de las shell bash":http://ss64.com/bash/syntax-keyboard.html<br />
<br />
== Obtención de ayuda ==<br />
<br />
Una de las principales necesidades de los usuarios que empiezan con Linux es poder acceder a recursos de ayuda sobre los comandos de la shell. Existen varios comandos que muestran ayuda de comandos shell. El más conocido y que muestra la información más completa es '''man'''. Este comando posee una sintaxis básica del modo:<br />
<br />
'''man comando'''<br />
<br />
Por ejemplo:<br />
<br />
<pre><br />
man ls<br />
</pre><br />
<br />
mostraría información sobre el comando ls. Una vez que se ejecuta el comando se entra en una sesión interactiva en la que se puede avanzar por la información mostrada en la pantalla. Para avanzar página usamos la tecla "espacio", para saltar de línea "intro" y para salir de la página del '''man'''ual pulsamos "q".<br />
Las páginas del manual se estructuran en varias secciones:<br />
<br />
* Comandos, programas y aplicaciones<br />
* Llamadas al sistema<br />
* Funciones de librería<br />
* Ficheros especiales<br />
* Formatos de ficheros<br />
* Juegos<br />
* Otros<br />
* Herramientas de administración del sistema<br />
<br />
como es posible encontrar información sobre un comando en varias de las secciones puede restringirse a un ámbito de sección concreto, especificando el número en la llamada al comando. Por ejemplo:<br />
<br />
<pre><br />
man 5 ls<br />
</pre><br />
<br />
La opción -k del comando muestra otros comandos relacionados con el comando pasado como parámetro a man. Además muestra información de en qué sección se encuentra la información relacionada.<br />
<br />
Un truco útil es redirigir la salida del comando man hacia un archivo, dónde posteriormente analizar la información, imprimirla, etc.<br />
<br />
<pre><br />
man grep > salida_grep.dat<br />
</pre><br />
<br />
Otros modos de ver ayuda en el sistema Linux son el comando '''apropos''' (ya desaparecido en algunas distros) y las opción --help (o -h) disponible en muchos de los comandos. También existe el comando '''type''' que indica información sobre ubicación de un comando especificado.<br />
<br />
Otros comandos útiles relacionados con el entorno son '''which''' que nos da la ruta al ejecutable pasado como parámetro o '''whereis''', que muestra información de las rutas en el sistema relacionados con el comando pasado como parámetro<br />
<br />
<pre><br />
which ifconfig<br />
</pre><br />
<br />
mostraría '''/sbin/ifconfig'''<br />
<br />
<pre><br />
whereis ifconfig<br />
</pre><br />
<br />
mostraría '''ifconfig: /sbin/ifconfig /usr/share/man/man8/ifconfig.8.gz'''<br />
<br />
== Variables de entorno. PATH ==<br />
<br />
Las variables de entorno son pares del tipo CLAVE=VALOR definidos en un ámbito concreto de la sesión de trabajo del usuario. Pueden tener carácter local o global y son fundamentales para automatizar algunas tareas importantes. Por ejemplo, cuando invocamos a un ejecutable desde la shell debemos, o bien escribir la ruta absoluta al comando, por ejemplo '''/usr/bin/who''', o bien escribir simplemente el nombre del comando '''who''' en este último caso el Sistema debe de saber de algún modo dónde tiene que buscar el comando invocado, pues de lo contrario arrojará un error del tipo "Unrecognized comand". La variable de entorno que almacena rutas de búsqueda predeterminada es PATH y se le asignan valores por defecto durante la creación de los usuarios. Es posible actualizar su valor y añadir nuevas rutas de búsqueda.<br />
Para visualizar las variables de entorno de vuestra sesión ejecutad el comando '''env''' veréis un listado de la definición de las variables de entorno para vuestro usuario. Las variables pueden tener ámbito local, para la sesión de trabajo actual, o ámbito global, es decir, que aplicarían siempre.<br />
Para crear una variables de entorno que solo aplique a la sesión de trabajo actual escribimos por ejemplo:<br />
<br />
<pre><br />
$ VAR="HOLA MUNDO"<br />
$ echo $VAR<br />
HOLA MUNDO<br />
$<br />
</pre><br />
<br />
Se define la variable de entorno local VAR con valor "HOLA MUNDO" (notad que hay que poner las comillas pues de lo contrario cogerá solo HOLA e intentará ejecutar MUNDO como un comando). A continuación se ejecuta el comando '''echo''' que envía a la salida estándar (la pantalla) el valor de la cadena pasada como parámetro, en este caso la variable de entorno. Por tanto la salida es "HOLA MUNDO".<br />
Si cerráis la consola, abrís una nueva y ejectuáis de nuevo el comando anterior veréis que no escribe nada, esto es porque la variable de entorno es local a la sesión de trabajo y se elimina cuando ésta concluye.<br />
<br />
Para definir '''variables de entorno de usuario''' que no pierdan su valor después de cerrar sesión podemos editar el archivo '''.bashrc''' dentro del HOME del usuario (/home/<nombre_usuario>), añadiendo la línea CLAVE=VALOR correspondiente a la variable a definir. Para que coja el valor definido podéis reiniciar la shell o escribir el comando<br />
<br />
<pre><br />
source .bashrc<br />
</pre><br />
<br />
El archivo '''.bashrc''' se ejecuta cuando se inicia una sesión interactiva del usuario.<br />
<br />
Para definir '''variables de entorno globales''' se utilizaba el comando '''export''', sin embargo es mejor hacerlo editando el archivo de texto '''/etc/environment''' (aunque también se podría hacer en /etc/profile) y añadiendo la variable correspondiente en formato CLAVE=VALOR al archivo. Será necesario reiniciar para que el Sistema tenga en cuenta la nueva variable.<br />
<br />
El archivo '''/etc/rc.local''' es una ubicación adecuada para invocar cualquier tipo de comando o script que se debe ejecutar después del inicio de cualquier nivel multiusuario. Debe de contener la línea '''exit 0''' al final de su contenido. <br />
<br />
== Algunos comandos básicos ==<br />
<br />
* exit<br />
* who<br />
* date<br />
* passwd<br />
* echo<br />
* clear<br />
* history<br />
* man<br />
* apropos<br />
* whereis<br />
* grep<br />
* basename<br />
* locate<br />
<br />
Opciones del comando date. Ejemplo: date +%a,%d-%m-%Y,%H:%M:%S<br />
<br />
[[Archivo:date.png]]<br />
<br />
'''Buscador de comandos en el history''': Para activar la '''reverse-i-search''', que permite realizar una búsqueda en los últimos comandos del histórico, y así poder recuperarlos y volverlos a ejecutar, pulsamos la combinación de teclas '''CTRL+R'''<br />
<br />
= Redirecciones y Tuberías =<br />
<br />
'''Redirecciones:'''<br />
Cuando trabajamos con la shell siempre existe un entorno de E/S asociado, esto es una Entrada y una Salida estándar. Por defecto la Entrada estándar es el teclado y la Salida estándar, la pantalla. También existe otra interfaz de salida, denominada Error estándar, que indica hacia dónde se envían las condiciones de error que pueden ocurrir durante la ejecución de los comandos. Por defecto el archivo de Error estándar también es la pantalla.<br />
<br />
Es posible redirigir la Entrada y Salida de un proceso para que, por ejemplo, tome los datos de entrada de un fichero o los envíe a un fichero (recordad que en Linux todo se modela como un archivo, por lo que el teclado (stdin) es realmente un archivo y la pantalla (stdout) también se maneja a través de un archivo).<br />
<br />
<pre><br />
$ echo "HOLA MUNDO" > salida.dat<br />
</pre><br />
<br />
El comando anterior envía la salida del comando '''echo''' al archivo '''salida.dat'''. Si accedemos al contenido del archivo salida.date veremos que contiene el texto HOLA MUNDO.<br />
<br />
<pre><br />
$ wc < entrada.dat<br />
</pre><br />
<br />
El comando wc anterior tomaría la Entrada del archivo entrada.dat y mostraría el resultado correspondiente.<br />
<br />
Cuando se redirige la Salida estándar hacia un archivo éste se crea sino existe y en caso de que exista se borra el contenido anterior y se sustituye por el nuevo. Para añadir contenido, sin borrar el contenido anterior, se utiliza el carácter doble >> en la redirección:<br />
<br />
<pre><br />
$ echo "HOLA MUNDO OTRA VEZ" >> salida.dat<br />
</pre><br />
<br />
añadiría al contenido del archivo el texto "HOLA MUNDO OTRA VEZ"<br />
<br />
'''Tuberías:'''<br />
Las Tuberías (pipelines) son un mecanismo rudimentario, pero muy efectivo, de comunicación entre procesos. Básicamente las Tuberías se utilizan para hacer que la entrada de un programa sea la salida de otro. Es la combinación de dos mecanismos de redirección de Entrada y Salida, la redirección de la Salida del primer programa y la redirección de la Entrada del segundo. Esto se entenderá mejor con un ejemplo:<br />
<br />
<pre><br />
$ who | grep root<br />
</pre><br />
<br />
El comando anterior ejecuta un '''who''', que muestra los usuarios conectados al Sistema, y dedirige su salida hacia la entrada del comando '''grep''', que filtra los resultados por un patrón. En este caso el resultado es mostrar solamente las sesiones iniciadas en el Sistema por el usuario root.<br />
<br />
El comando tee se utiliza para duplicar la salida estándar. Envía lo que recibe por entrada estándar a un fichero y a la salida estándar. Veamos un ejemplo:<br />
<br />
<pre><br />
cat /etc/passwd | tee fichero<br />
</pre><br />
<br />
Este comando tomaría como entrada la salida del comando cat /etc/passwd (que lista los contenidos del archivo /etc/passwd dónde se almacenan las cuentas de usuarios del sistema) y duplica la salida enviando una copia de lo que recibe por su entrada al fichero "fichero" y otra copia a la salida estándar (pantalla)<br />
<br />
= Ejecución de comandos en primer y segundo plano =<br />
<br />
Al ejecutar un comando desde la terminal, por defecto, la ejecución del mismo se hará en '''primer plano (foreground)''', es decir, en modo interactivo, el usuario deberá esperar a que termine la ejecución del mismo para poder continuar introduciendo comandos nuevos. Si introducimos un comando que necesite un tiempo considerable para ejecutarse, como por ejemplo un comando find de búsqueda en el sistema de archivos, tendremos que esperar a que concluya para poder seguir introduciendo comandos en la sesión interactiva de terminal.<br />
<br />
Para solucionar este problema podemos optar por ejecutar los comandos en '''segundo plano (background)''', esto es, sin necesidad de esperar a que concluyan para poder seguir trabajando en modo interactivo con la terminal. ¿Cómo se consigue esto?, la respuesta es añadir el operador '''&''' al final del comando, de este modo invocamos el comando para que se ejecute en segundo plano. Veamos un ejemplo<br />
<br />
<pre><br />
sudo find / -name '''.conf > ./find.out &<br />
</pre><br />
<br />
Ejecutará la búsqueda de archivos con extensión .conf en todo el sistema de archivos raíz volcando el resultado de salida de ese comando al archivo find.out en el directorio actual, lo cual podría consumir bastante tiempo. Añadiendo el '''&''' al final invocaremos el comando en segundo plano y por tanto podremos seguir trabajando con la consola sin necesidad de esperar a que el comando concluya<br />
<br />
Otro ejemplo<br />
<br />
<pre><br />
yes > /dev/null &<br />
</pre><br />
<br />
El comando yes es un comando para pruebas que lo que hace es enviar una salida continua del carácter "y" a la salida estándar. En este caso al redirigir la salida evitamos que envíe el resultado a la pantalla. Como queremos evitar que se llene de forma inútil espacio de disco utilizamos como archivo de salida '''/dev/null''', de modo que la salida de yes no ocupará lugar en el sistema de archivos. Al añadirle el '''&''' al final del comando lo ejecutaremos en segundo plano, con lo que podremos seguir trabajando con la shell.<br />
<br />
== El comando jobs ==<br />
<br />
En cualquier momento podemos ver los comandos que se están ejecutando en segundo plano mediante este comando. Además del comando la salida de jobs mostrará también un número que identifica el trabajo para poder interactuar con él de ser necesario<br />
<br />
<pre><br />
jobs<br />
[1]+ Ejecutando sudo find / -name '''.conf &<br />
[2]+ Ejecutando nohup cp -r /media/disco/20''' CIS/ &<br />
</pre><br />
<br />
== El comando fg ==<br />
<br />
Si en algún momento queremos traer a primer plano un trabajo que se está ejecutando en segundo plano, usaremos este comando. Si se invoca sin argumentos traerá a primer plano el trabajo más reciente ejecutado en segundo plano. Si se quiere traer a primer plano un trabajo determinado usamos el identificador numérico del trabajo para determinarlo. Veamos un ejemplo<br />
<br />
<pre><br />
fg %1<br />
</pre><br />
<br />
Traería a primer plano el trabajo con identificador 1 en segundo plano<br />
<br />
== El comando bg ==<br />
<br />
Es un comando simétrico del anterior, permite enviar a segundo plano un comando ejecutado en primer plano sin necesidad de deternerlo. Para poder utilizarlo previamente debemos pulsar '''CTRL+Z''', que detendrá el trabajo sin matarlo, para poder ejecutar éste en segundo plano. Veamos un ejemplo<br />
<br />
<pre><br />
* find / -ctime -1 > /tmp/changed-file-list.txt<br />
<br />
* [CTRL-Z]<br />
[2]+ Stopped find / -ctime -1 > /tmp/changed-file-list.txt<br />
<br />
* bg<br />
</pre><br />
<br />
El comando find se ejecuta en primer plano, al no introducirse el '''&''' al final del comando, posteriormente el trabajo se detiene con CTRL+Z. Por último, mediante el comando '''bg''' enviamos el trabajo a segundo plano<br />
<br />
== Comando kill para trabajos en segundo plano ==<br />
<br />
Si necesitamos matar un proceso que se está ejecutando en segundo plano usaremos el comando kill, utilizando como referencia al proceso del comando el identificador numérico que éste tiene asociado en segundo plano, es decir, el '''[id]''' que se visualiza mediante el comando '''jobs'''<br />
<br />
<pre><br />
kill %2<br />
</pre><br />
<br />
Mataría el proceso con [id] 2 en segundo plano<br />
<br />
= Ejecución de procesos independientes de la sesión =<br />
<br />
Otro problema común es como proceder cuando un trabajo toma tanto tiempo en terminar que es posible que se cierre la sesión de terminal en la que se invocó. Esto, debido al modelo de procesos jerárquico de Linux, causaría que al morir el padre, el proceso de la terminal, todos sus hijos, incluído el comando que no ha terminado también sean eliminados. ¿Como evitamos esto?. La respuesta es mediante el comando '''nohup'''. Precediendo el comando a ejecutar del comando '''nohup''', independizamos éste de la terminal desde la cual se invoca, de modo que si cerramos ésta el proceso seguirá ejecutándose en el sistema. Veamos un ejemplo<br />
<br />
<pre><br />
nohup find / -name '''.dat &<br />
</pre><br />
<br />
Ejecutaría el find en segundo plano y además lo haría de modo que si cerramos la sesión interactiva de terminal el find continuaría ejecutándose<br />
<br />
= Filtros y comandos de ordenación =<br />
<br />
'''Filtros''':<br />
<br />
Un filtro permite establecer algún tipo de criterio sobre la información que queremos mostrar. Por ejemplo, para ver en los logs del sistema aquellas acciones relacionadas con el proceso de logueo de los usuarios correspondiente al usuario root escribiríamos lo siguiente:<br />
<br />
<pre><br />
cat /var/log/auth.log | grep root<br />
</pre><br />
<br />
El comando '''cat''' lista los contenidos del archivo, a continuación envíe su salida a la entrada del comando '''grep''' (tubería) y grep filtra las líneas de texto del archivo en las que aparezca el término "root".<br />
<br />
Por tanto uno de los usos del comando grep es buscar en las líneas de un determinado archivo, o salida de un comando, las ocurrencia de la expresión indicada. La sintaxis del comando es:<br />
<br />
'''grep [-opciones] expresion_regular fichero(s)'''<br />
<br />
donde las opciones modifican su funcionamiento, la '''expresión regular''' identifica el patrón a buscar (una expresión regular puede contener metacaracteres y comodines que sustituyen a otros caracteres y expresar patrones complejos) y '''fichero(s)''' es el o los ficheros en los que vamos a aplicar el comando.<br />
<br />
Algunas opciones interesantes de grep:<br />
<br />
* '''-i''': Búsquedas case insensitive, es decir no sensibles a mayúsculas minúsculas<br />
* '''-r''': Búsquedas recursivas en el directorio actual y subdirectorios<br />
* '''-v''': Búsqueda inversa, muestra las líneas que no verifican el patrón de búsqueda de la expresión<br />
* '''-c''': Cuenta el número de coincidencias que verifican el patrón<br />
* '''-B N''': Donde N es un número positivo, muestra las N líneas antes (Before) de la coincidencia<br />
* '''-A N''': Donde N es un número positivo, muestra las N líneas después (After) de la coincidencia<br />
* '''-C N''': Donde N es un número positivo, muestra las N líneas antes y después de la coincidencia<br />
* '''-n''': Muestra el número de línea de la coincidencia<br />
<br />
El trabajo con expresiones regulares dota de un gran potencial y expresividad a ciertos comandos de Linux. Mediante el uso de expresiones regulares y de otras herramientas todavía más potentes (como awk) podemos definir y caracterizar patrones textuales que nos permitirán simplificar tareas de búsqueda, sustitución y ordenación de textos.<br />
<br />
La variable de entorno '''GREP_OPTIONS''' controla el funcionamiento de grep, por ejemplo para resaltar el color de las coincidencias en la búsqueda. Por ejemplo lo siguiente permite que las coincidencias se muestren resaltadas<br />
<br />
<pre><br />
export GREP_OPTIONS='--color=auto' GREP_COLOR='100;8'<br />
</pre><br />
<br />
== Algunos ejemplos con grep ==<br />
<br />
Mostraría las líneas del archivo /etc/group que coincidan con la expresión de búsqueda "ROOT" de modo no sensible a mayúsculas y minúsculas<br />
<pre><br />
grep -i "ROOT" /etc/group<br />
</pre><br />
<br />
Mostraría las líneas del archivo /etc/passwd que no contengan la expresión de búsqueda root<br />
<pre><br />
grep -v "root" /etc/passwd<br />
</pre><br />
<br />
Combinando las dos anteriores:<br />
<pre><br />
grep -v -i "ROOT" /etc/passwd<br />
</pre><br />
<br />
Mostraría las 3 líneas después de la coincidencia de búsqueda:<br />
<pre><br />
grep -A 3 -i "root" /etc/passwd<br />
</pre><br />
<br />
<br />
'''Algunas herramientas de ordenación:'''<br />
<br />
Un comando útil cuyo objetivo es ordenar alfanumériamente el contenido de un archivo o la salida de un comando es '''sort'''. Su sintaxis es:<br />
<br />
'''sort [opciones] fichero'''<br />
<br />
Algunas opciones: -n, indica que la ordenación es numérica y no alfabética, -r hace una ordenación "inversa". Un ejemplo:<br />
<br />
<pre><br />
sort -r /etc/passwd<br />
</pre><br />
<br />
ordenaría, a la inversa (es decir empezando por las líneas que comienzan por z y finalizando con las que empiezan por a) los contenidos del archivo /etc/passwd<br />
<br />
'''uniq'''<br />
<br />
Comando utilizado en conjunto con sort y que elimina los duplicados después de una operación de tipo sort<br />
<br />
<pre><br />
sort -r /etc/passwd | uniq<br />
</pre><br />
<br />
= El comando cut =<br />
<br />
Este es un comando útil porque permite '''cortar''' las salidas tabuladas de los comandos para seleccionar simplemente una columna, o intervalo, de la salida. Por ejemplo, si ejecutamos<br />
<br />
<pre><br />
ls -la /etc/rc2.d<br />
</pre><br />
<br />
La salida será:<br />
<br />
<pre><br />
total 12<br />
drwxr-xr-x 2 root root 4096 Aug 1 00:38 .<br />
drwxr-xr-x 94 root root 4096 Aug 20 21:13 ..<br />
-rw-r--r-- 1 root root 677 Jul 26 2012 README<br />
lrwxrwxrwx 1 root root 31 May 1 2012 S14xe-linux-distribution -> ../init.d/xe-linux-distribution<br />
lrwxrwxrwx 1 root root 23 Aug 1 00:38 S20clamav-daemon -> ../init.d/clamav-daemon<br />
lrwxrwxrwx 1 root root 26 Aug 1 00:38 S20clamav-freshclam -> ../init.d/clamav-freshclam<br />
lrwxrwxrwx 1 root root 20 Jul 12 22:29 S20nova-agent -> ../init.d/nova-agent<br />
lrwxrwxrwx 1 root root 13 Jul 31 18:30 S23ntp -> ../init.d/ntp<br />
lrwxrwxrwx 1 root root 15 May 1 2012 S50rsync -> ../init.d/rsync<br />
lrwxrwxrwx 1 root root 19 May 1 2012 S70dns-clean -> ../init.d/dns-clean<br />
lrwxrwxrwx 1 root root 18 May 1 2012 S70pppd-dns -> ../init.d/pppd-dns<br />
lrwxrwxrwx 1 root root 14 Mar 5 03:52 S75sudo -> ../init.d/sudo<br />
lrwxrwxrwx 1 root root 17 Jul 31 11:28 S91apache2 -> ../init.d/apache2<br />
lrwxrwxrwx 1 root root 18 Jul 31 12:32 S99fail2ban -> ../init.d/fail2ban<br />
lrwxrwxrwx 1 root root 21 May 1 2012 S99grub-common -> ../init.d/grub-common<br />
lrwxrwxrwx 1 root root 18 May 1 2012 S99ondemand -> ../init.d/ondemand<br />
lrwxrwxrwx 1 root root 18 May 1 2012 S99rc.local -> ../init.d/rc.local<br />
</pre><br />
<br />
Si solo queremos que se muestre una columna, por ejemplo la correspondiente al usuario propietario, podríamos utilizar el comando cut<br />
<br />
<pre><br />
ls -la /etc/rc2.d | cut -d' ' -f4<br />
</pre><br />
<br />
La expresión anterior indica: cortar, utilizando el '''separador espacio (-d ' ' )''', la salida del comando '''ls -la /etc/rc2.d''' y '''mostrar por salida la columna 4 (-f4)'''<br />
Por supuesto que puede especificarse otro separador, especificándolo en la opción '''-d''', y de posición del campo, con la opción '''-f'''<br />
<br />
Para más información ejecutar<br />
<br />
<pre><br />
cut --help<br />
</pre><br />
<br />
= El comando find =<br />
<br />
Este es uno de los comandos más potentes y útiles de búsqueda en Linux. Admite una sintaxis muy flexible, aunque básicamente esta consiste en:<br />
<br />
'''find directorio atributos'''<br />
<br />
dónde _directorio_ indica el punto de partida de la búsqueda y _atributos_ se refiere a las características que deben poseer los archivos buscados.<br />
Además, el comando find soporta cierto nivel de interacción, en la medida en que se puede especificar, con la opción -exec, un comando para ejecutar por cada uno de los archivos que verifiquen la condición indicada en los atributos del comando.<br />
El comando find devuelve como salida una lista con los archivos que verifiquen la condición indicada mediante los atributos. Se puede especificar mediante el parámetro n (+n, más de n, -n, menos de n, o n, exactamente n) que la condición del atributo se satisfaga en relación a el número indicado por n. Veamos algunos de los atributos soportados:<br />
* '''-atime n''': accedido en los últimos n días<br />
* '''-mtime n''': modificados sus datos en los últimos n días<br />
* '''-ctime n''': estado del archivo modificado en los últimos n días<br />
* '''-group grupo''': cierto si el grupo del fichero es el indicado<br />
* '''-nogroup''': cierto si el fichero no tiene grupo válido<br />
* '''-nouser''': cierto si pertenece a un usuario no dado de alta en el sistema<br />
* '''-user usuario''': cierto si el fichero es propiedad del usuario<br />
* '''-inum n''': cierto si el archivo tiene el i-nodo n<br />
* '''-ls''': siempre cierto, se usa para mostrar información del fichero<br />
* '''-newer fichero''': cierto si el fichero es más nuevo que el fichero indicado<br />
* '''-name patrón''': cierto si el nombre del fichero está incluido en el conjunto indicado por la expresión regular del patrón<br />
* '''-exec''': opción muy importante, permite la ejecución de un comando. Tiene que terminar con el carácter ;. La expresión {} representa a la ocurrencia de cada archivo que verifique la condición<br />
* '''-ok''': igual que -exec, salvo que pide confirmación antes de ejecutar<br />
* '''-perm -mode''': cierto para aquellos ficheros que tienen los permisos indicados<br />
* '''-print''': siempre es cierto, usado para imprimir la ruta de los ficheros seleccionados<br />
* '''-type c''': cierto si el tipo de fichero es el indicado (c puede ser d, directorio, f, fichero normal, l, enlace)<br />
* '''-size n[c]''': cierto si el fichero es de n bloques (512 bytes), si se incluye la c, el tamaño es tratado como bytes<br />
<br />
Se pueden utilizar operadores lógicos para dotar de mayor expresividad a las condiciones del comando. Las opciones de agrupación y operadores lógicos son:<br />
! niega una condición<br />
-o O Lógico<br />
-a A Lógico<br />
() Los paréntesis se utilizan para agrupar condiciones<br />
<br />
'''Ejemplos:'''<br />
<br />
<pre><br />
find . -name "cuentas'''"<br />
</pre><br />
<br />
Encuentra todos los archivos dentro del directorio actual (.) y todos los subdirectorios cuyo nombre empieza por "cuentas"<br />
<br />
<pre><br />
find . -user irene<br />
</pre><br />
<br />
Encuentra todos los archivos dentro del directorio actual y subdirectorios propiedad del usuario irene<br />
<br />
<pre><br />
find . -user irene -mtime 2<br />
</pre><br />
<br />
Encuentra todos los archivos propiedad de irene que hayan sido modificados en los últimos 2 días<br />
<br />
<pre><br />
find . -name "tmp'''" -exec rm {} \;<br />
</pre><br />
<br />
Encuentra todos los archivos cuyo nombre empiece por tmp y ejecuta un rm (borrado) sobre ellos. Notar que el ; ha sido escapado por ser un carácter con significado para el intérprete de comandos<br />
<br />
<pre><br />
find / \(-name '''.o -o -name '''.out\) -a -perm -o+w<br />
</pre><br />
<br />
En este ejemplo vemos una concatenación lógica con un "O lógico" "-o", dentro del paréntesis y un "Y lógico" "-a". Buscaría aquellos archivos que verifiquen que su nombre acaba en .o o .out y que al mismo tiempo tengan en su máscara de permisos o+w (permiso de escrita para otros). De nuevo es necesario escapar los caracteres con significado para la shell, en este caso los paréntesis<br />
<br />
Comando para visualizar los archivos propiedad de root con setuid activado:<br />
<br />
<pre>sudo find / -perm -u=rws -a -user root</pre><br />
<br />
== Comando locate ==<br />
<br />
Un comando similar a find que realiza búsquedas instantáneas, a diferencia de éste que busca recursivamente en el sistema de archivos según los criterios especificados, es '''locate'''. Con locate podemos obtener información de localización de archivos y directorios. Algunas opciones del mismo son:<br />
<br />
* '''-e''': busca solo archivos existentes que no hayan sido borrados<br />
* '''-i''': no distingue entre mayúsculas y minúsculas<br />
* '''-c''': muestra el número de archivos cuyo nombre coincide con el patrón de búsqueda indicado<br />
<br />
<pre><br />
locate ifconfig<br />
</pre><br />
<br />
Mostraría todos los archivos del sistema relacionados con el término ifconfig, es decir que contengan ese término en su nombre<br />
<br />
La diferencia principal entre find y locate es que este último localiza los resultados de búsqueda en una base de datos que se actualiza periódicamente, mediante el procesamiento del sistema de archivos. La base de datos reside en el directorio '''/var/lib/mlocate/mlocate.db''' u el archivo de configuración '''/etc/updatedb.conf''' permite configurar el proceso de actualización de la misma<br />
<br />
= Sustituciones de Shell =<br />
<br />
== Caracteres ` ` y expresión $() ==<br />
<br />
Si encerramos un texto '''`comando`''' en Linux (Tecla también de los caracteres [ y ^ que se obtiene pulsando la tecla y luego "espacio") obtendremos la ejecución del resultado del '''comando indicado por el texto'''. Esta construcción es sintácticamente equivalente a '''$(comando)''' '''Por ejemplo:'''<br />
<br />
<pre><br />
echo hola, soy `whoami`<br />
</pre><br />
<br />
Nos devolverá un saludo del tipo "hola, soy <nombre_usuario>", sustituyendo el <nombre_usuario> por el nombre del usuario de la sesión actual<br />
Es útil para obtener información dinámica, resultado de la ejecución de comandos. Se usa mucho en scripting y cuando queremos usar la salida textual de un comando como entrada de otro. <br />
<br />
Un comando similar sería:<br />
<br />
<pre><br />
echo hola, son las: $(date +%H:%M)<br />
</pre><br />
<br />
Que muestra un texto indicando la hora actual, precedido de "hola, son las:..."<br />
<br />
Imaginemos que tenemos un archivo install.dat dónde tenemos la siguiente línea:<br />
<br />
apt-get install mysql apache2 php5 phpmyadmin slapd slurpd phpldapadmin<br />
<br />
Que no es más que un conjunto de paquetes que queremos instalar. ¿Cómo podemos ejecutar ese comando sin tener que "copiar y pegar" el contenido a la consola?, es decir, ¿cómo podemos utilizar un texto arbitrario (en este caso dentro de un archivo) para que se ejecute como un comando de shell?. Así:<br />
<br />
<pre><br />
`cat install.dat`<br />
</pre><br />
<br />
Esto ejecutaría el resultado de listar el contenido del archivo de texto install.dat, que es, ni más ni menos, que lo que queremos hacer, sin necesidad de copiar ni pegar nada. Es muy útil cuando queramos hacer instalaciones desde tutoriales y no podemos copiar y pegar directamente los comandos en la terminal de destino (por ejemplo si es una máquina virtual o remota). Crearíamos un texto en un archivo local con el contenido a ejecutar, copiamos, por ejemplo con scp el archivo en el sistema destino y ejecutamos un comando similar al anterior.<br />
<br />
= Referencias =<br />
Introducción a grep<br />
* https://www.thegeekstuff.com/2009/03/15-practical-unix-grep-command-examples<br />
* http://docs.oracle.com/cd/E19620-01/805-7644/6j76klop3/index.html<br />
<br />
Lista de comandos Linux/Debian:<br />
* http://www.esdebian.org/wiki/lista-comandos-gnulinux-i<br />
* http://www.esdebian.org/wiki/lista-comandos-gnulinux-ii<br />
* http://www.esdebian.org/wiki/lista-comandos-gnulinux-iii<br />
<br />
Debian Environment Variables:<br />
* http://wiki.debian.org/EnvironmentVariables<br />
<br />
[[Comandos básicos de xestión e administración en linux|Volver]]<br />
<br />
JavierFP 16:31 08 ene 2019 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Date.png&diff=65268Archivo:Date.png2019-01-08T17:24:55Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Fundamentos_da_Xesti%C3%B3n_da_E/S&diff=65228Fundamentos da Xestión da E/S2018-12-05T17:49:25Z<p>Javierfp: /* Dispositivos */</p>
<hr />
<div>= Funciones y Objetivos =<br />
<br />
== Introducción ==<br />
<br />
Como ya hemos visto en repetidas ocasiones, los 2 objetivos principales de un Sistema Operativo son, la Interfaz de Máquina Extendida (abstracción de los elementos físicos y dependientes del hardware en modelos más comunes y manejables) y la Gestión de Recursos.<br />
Toda computadora debe actuar con su entorno, bien recibiendo información de Entrada, o bien mostrando información de Salida; resultado de aplicar un programa a un conjunto de datos de Entrada. Por tanto, la gestión de E/S es fundamental en la operativa de un sistema.<br />
Por dispositivos de E/S hacemos referencia a todos los dispositivos que interactuan con el exterior, es decir aquellos que actúan como periféricos y que se pueden conectar a la computadora. La conexión puede realizarse bien explícitamente, o bien formando parte del propio hardware de la misma. El Sistema Operativo debe comunicarse con ellos y, por tanto, disponder de todos los mecanismos para llevar a cabo la comunicación, siendo el encargado de controlar el acceso de los procesos a los mismos.<br />
<br />
== Dispositivos ==<br />
<br />
Los dispositivos son los componentes físicos cuya labor es realizar algún tipo de transferencia desde y/o hacia la CPU. Consta de 2 partes físicas:<br />
<br />
* '''El dispositivo''': En sí, es decir el propio dispositivo físico<br />
<br />
[[Archivo:disco-scsi.jpg]]<br />
<br />
Imagen de un disco de tipo SCSI. Todos los discos de este tipo, independientemente del fabricante, se conectan de un mismo modo a la placa, a través de una controladora SCSI en ésta. En la imagen puede verse claramente el conector SCSI que permitirá conectar el disco a la controladora en la placa base.<br />
<br />
* '''Adaptador o Controladora Hardware''': Es la parte de la electrónica del dispositivo que adapta o estandariza su funcionamiento para la interconexión con hardware genérico. <br />
Por ejemplo: Un disco duro, de un fabricante X, dispone de unas características física y constructivas concretas, diferentes de las de un dispositivo del fabricante Y. Sin embargo, a la hora de conectar esos dispositivos a una placa, para el Sistema Operativo éstos deben de ser vistos de un modo uniforme, sin grandes diferencias entre ellos. Este trabajo es el que realiza el Adaptador o Controladora, el cual adapta e independiza el dispositivo del hardware real que define su funcionamiento.<br />
Concretando un poco más, existen especificaciones y estándares de la industria que definen interfaces de conexión o adaptación de discos duros. Algunos de ellos, muy conocidos, son: IDE, SATA, SAAS, SCSI. Todos ellos vienen definidos por un estándar internacional, que unifica su estructura y el modo de comunicarse con ellos. La electrónica responsable de implementar esas características estándar es la que constituye la Controladora del dispositivo.<br />
Este principio rige para todos los dispositivos, susceptibles de conectarse de un modo, o mediante una interfaz concreta, por ejemplo: USB, FireWire, SATA, IDE, etc. Los dispositivos derivados y que siguen la especificación correspondiente, un disco externo USB, un disco interno SCSI, un disco SATA, un Pendrive, una impresora, etc., deberán de incorporar en su electrónica, o al menos disponer del conector de adaptación correspondiente en caso de que esa electrónica esté en la placa base, del interfaz correspondiente para trabajar con la especificación concreta.<br />
Es muy importante '''no confundir''', por un lado la '''Controladora o Adaptador Hardware''', y el '''controlador de dispositivo software (driver)'''. Aunque para ambos se utiliza asiduamente el término "controlador/a" el primero es físico (electrónico) y el segundo es un componente software que se integra con el Sistema Operativo para comunicarse con el correspondiente dispositivo.<br />
<br />
[[Archivo:csata.jpg]]<br />
<br />
En esta imagen puede verse una controladora SATA, a la que se pueden conectar dispositivos (discos, unidades ópticas) que se adapten a esa especificación de interfaz<br />
<br />
Los dispositivos se clasifican en función de:<br />
<br />
* Tipo de interacción con el sistema<br />
** Entrada: Teclado, ratón, micrófono...<br />
** Salida: Pantalla, impresora, altavoces...<br />
** Entrada/Salida: Pantalla táctil, impresora multifunción (con escáner), etc.<br />
<br />
* Modo de funcionamiento<br />
** Bloques: Funcionan intercambiando información haciendo referencia (direccionando) unidades de almacenamiento, denominadas bloques. Por ejemplo: disco duro, CD-DVD...<br />
** Caracteres: Funcionan intercambiando información mediante una secuencia de símbolos ordenados. Por ejemplo: módem, tarjeta de red, pantalla, teclado, ratón, impresora...<br />
<br />
== Objetivos ==<br />
<br />
Ya estamos en condiciones de enunciar los objetivos y funcionalidad que debe de proporcionar un Sistema Operativo en lo relativo a la gestión de la E/S:<br />
<br />
* '''Independencia del dispositivo''': Gestionar los dispositivos de un modo abstracto, de modo que éstos se vean como elementos de E/S sin más. De este modo las aplicaciones, a través del Sistema Operativo, pueden comunicarse con los dispositivos de un modo sencillo y normalizado. Por ejemplo con llamadas como: "Abrir dispositivo", "Leer de dispositivo", "Escribir en dispositivo", etc., realizadas lógicamente a través de las interfaces de librerías de los lenguajes de programación correspondientes.<br />
* '''Denominación uniforme''': Utilizar un modelo de denominación coherente y compartido por cualquier dispositivo de E/S. El caso más importante es el sistema de denominación de archivos y directorios, que utiliza conceptos como ruta relativa y ruta absoluta para hacer referencia a éstos.<br />
* '''Manejo de errores''': Ocultar a los programas las condiciones de error que hayan podido ocurrir durante el acceso a un dispositivo de E/S, de modo que el usuario no sea consciente de los reintentos en caso de fallo de una operación. En caso de que una operación no pueda realizarse se notificará simplemente con un mensaje de error.<br />
* '''Almacenamiento intermedio de datos (búffer)''': Todos los datos transferidos a y desde un dispositivo a la memoria principal deben de almacenarse provisionalmente en zonas de memoria intermedia, o búffers. El motivo de que esto sea así es principalmente por las diferencias de velocidad de operación de CPU, Memoria y dispositivos y a la ejecución concurrente de procesos (multitarea), no puede saberse a priori cuando realmente se hará una transferencia y cuánto tiempo tardará. Por este motivo se reservan zonas de memoria intermedia en el propio dispositivo (en la controladora hardware) y en la memoria principal de la computadora.<br />
<br />
= Espacios de direccionamiento =<br />
<br />
La forma que tiene el Sistema Operativo de conocer el estado de un dispositivo es leyendo la información que el propio dispositivo le proporciona. Por tanto, para hacer referencia a un dispositivo necesitamos un modo de poder comunicarnos con él. La manera de controlar de este aspecto suele venir parcialmente integrada en la propia lógica de la controladora hardware. La controladora hardware dispone de una serie de registros de estado y de un búffer de datos que deben ser accesibles de algún modo para la CPU. La clave está en cómo puede la CPU visualizar estos registros imprescindibles para comunicarse con el dispositivo. Existen 2 alternativas:<br />
<br />
* '''Espacios de direcciones separados para memoria y dispositivos''': En este caso la CPU utiliza 2 modos de direccionamiento independientes, uno para identificar los registros de los dispositivos en sí, que se denominan '''Puertos de E/S''' y otro para hacer referencia a la propia memoria principal. La CPU dispone de instrucciones diferentes para realizar operaciones del tipo "acceso a Puerto de E/S" y otras instrucciones para operaciones del tipo "Acceso a memoria principal".<br />
<br />
* '''Único espacio de direcciones para memoria y dispositivos''': En esta modalidad se utiliza un direccionamiento uniforme para dispositivos y para la memoria principal, de modo que, para la CPU no hay diferencias en este aspecto. Por tanto las instrucciones de acceso a datos en la memoria principal y a la información de un dispositivo son las mismas. En sistemas que utilizan esta aproximación, la mayoría en la actualidad, se reserva una zona de la memoria principal para ubicar los Puertos de E/S de los dispositivos, habitualmente un espacio reservado del orden de los KB, y el resto del espacio de direcciones de la memoria principal se utiliza para la asignación de memoria a los espacios de direcciones de los procesos.<br />
<br />
[[Archivo:5-2.jpg]]<br />
<br />
a) Espacios separados para Puertos de E/S y memoria<br />
b) Espacio único para memoria y Puertos de E/S<br />
c) Modelo mixto<br />
<br />
[[Archivo:5-3.jpg]]<br />
<br />
a) Canal compartido para direcciones referentes a memoria y puertos de dispositivos<br />
b) Canales físicos separados para direcciones de memoria y puertos de dispositivos <br />
<br />
Las ventajas del segundo modelo en relación al primero son:<br />
<br />
* No se necesitan instrucciones específicas de la CPU para el acceso a los dispositivos<br />
* Se pueden construir el software que accede a los dispositivos utilizando un lenguaje de programación de alto nivel, como C. En la aproximación basada en separar Puertos de E/S y memoria principal es necesario escribir las instrucciones de acceso a Puertos de E/S en lenguaje ensamblador<br />
<br />
= Modalidades de E/S =<br />
<br />
== E/S programada ==<br />
<br />
El sistema más simple para gestionar la E/S es dejarle todo el trabajo a la CPU. En la modalidad de E/S programada las transferencias de datos de E/S son supervisadas y atentidas por la CPU, de modo que mientras realiza este trabajo no puede atender ninguna otra tarea del sistema.<br />
Aún así la E/S programada se utiliza en casos en los que la complejidad de una alternativa no compensa la simplicidad inherente a la E/S programada. Un ejemplo es la gestión de dispositivos de bajo tráfico y operación asíncrona, este es el caso por ejemplo de teclado y ratón. La CPU "sondea" periódicamente estos dispositivos para determinar si han enviado datos desde el último sondeo. Este modo de operación se denomina "polling" (sondeo) y solo se utiliza en casos concretos como el anterior. Para dispositivos que tienen que enviar cantidades de información grandes (como discos, unidades ópticas, conexiones de red, etc.) no es adecuado el uso de la E/S programada.<br />
<br />
== E/S controlada por interrupciones ==<br />
<br />
Una evolución conceptual para gestionar la E/S es el punto de vista basado en interrupciones. En esta modalidad, en lugar de que la CPU tenga que sondear al dispositivo en cuestión (accediendo a la información en los registros de su controladora) es el propio dispositivo el que notifica a la CPU por cada operación de transferencia realizada. Aún así la transferencia de datos del dispositivo a memoria principal sigue estando controlada por la CPU, sin embargo durante el tiempo en que se leen los datos del dispositivo, o se escriben en éste en caso de transferencias de salida, éste no molesta de ningún modo a la CPU que podrá atender a otros procesos del sistema.<br />
<br />
[[Archivo:5-5.jpg]]<br />
<br />
Gráfico que ilustra la operativa de un procedimiento de interrupción<br />
<br />
== E/S mediante DMA ==<br />
<br />
Este es el modelo de E/S más sofisticado y eficiente, sobretodo para dispositivos con una alta demanda de transferencia de datos (discos, cd, dvd, conexiones de red, etc.).<br />
DMA solventa las carencias del modelo basado en interrupciones, el cual no es eficiente. El motivo de esto es que, en el modelo basado en interrupciones, para cada transferencia desde el búffer de la controladora del dispositivo a memoria principal, la CPU tiene que intervenir para escribir esos datos en memoria. Lo mismo para el caso de escrituras, la CPU debe tomar el control para transferir los datos desde la memoria principal al búffer del dispositivo.<br />
Para solucionar este problema, desde hace años, se viene utilizando el sistema DMA (Directory Memory Access, Aceso Directo a Memoria). Con la ayuda de un componente hardware, '''la controladora DMA''', la cual suele venir integrada en la placa para poder ser utilizada por varios dispositivos, se "delegan" las operaciones de E/S a la DMA, de modo que mientras dure la transferencia completa de datos, a o desde el dispositivo, la CPU no tenga que intervenir en absoluto, quedando liberada por completo para atender otros procesos durante las transferencias de E/S.<br />
<br />
[[Archivo:5-4.jpg]]<br />
<br />
Gráfico que muestra la operativa relacionada con una transferencia de E/S controlada por DMA<br />
<br />
# La CPU programa la controladora DMA para realizar la transferencia completa, indicando la dirección de memoria a partir de la cual se ubicarán los datos leídos y el número de transferencias a realizar<br />
# La DMA, acepta la petición y envía la primera petición de lectura del primer bloque de datos a la controladora del disco<br />
# Tras armar el búfer de datos, la controladora transfiere a memoria el bloque actual<br />
# La controladora de disco envía un acuse, ACK, de lectura del bloque a la DMA<br />
# El ciclo 2, 3, 4 se repite hasta que se lean todos los bloques solicitados inicialmente a la controladora DMA por la CPU<br />
# Cuando terminan de transferirse a memoria todos los bloques la controladora DMA interrumpe a la CPU para indicar que la transferencia completa ha finalizado<br />
<br />
= Capas o Niveles de E/S =<br />
<br />
== Introducción ==<br />
<br />
La gestión de E/S es una labor complicada y extensa debido al ecosistema de dispositivos, interfaces y estándares de interconexión. Por este motivo, siguiendo el mismo principio que en el diseño de arquitectura de redes de computadoras, se utiliza para definir su estructura un modelo basado en capas o niveles. Los modelos en capas permiten dividir un problema en aspectos, desde lo más concreto a lo más abstracto, utilizando una visión top-down (arriba-abajo) para diseñar un sistema de gestión adecuado y flexible.<br />
<br />
[[Archivo:5-11.jpg]]<br />
<br />
En este gráfico puede observarse la gestión de E/S del Sistema Operativo en un modelo basado en capas, desde lo más abstracto (capa superior) que representa el punto de vista del usuario, hasta lo más concreto (capa inferior) dónde se pueden ver los distintos dispositivos hardware.<br />
En los Sistemas Operativos actuales se utiliza un modelo en capas que responde a la estructura expuesta a continuación, desde lo más concreto y detallado (rutinas de tratamiento de interrupciones), hasta lo más general y abstracto (E/S en espacio de usuario)<br />
<br />
== Rutinas o procedimiento de tratamiento de interrupciones ==<br />
<br />
En el nivel más bajo el Sistema Operativo tiene que encargarse de los sucesos asíncronos que proceden de los dispositivos. Es decir, un dispositivo realiza los trabajos encomendados, pero no es posible anticipar cuando terminará de hacer esa tarea, por ese motivo es un modelo de naturaleza asíncrona. Las interrupciones son eventos o notificaciones que envían los dispositivos, a través de su controladora hardware, y que deben ser atendidas con urgencia por la CPU.<br />
Asociadas al tratamiento de las interrupciones están las rutinas o procedimientos de tratamiento de interrupción, los cuales realizan las tareas encomendadas para la atención y necesidades del dispositivo que provocó la interrupción. Por tanto, es mediante la interrupción y las rutinas o procedimientos de servicio a la interrupción, que se define la barrera que separa a hardware de software, constituyendo las fronteras de las mismas del lado del hardware las interrupciones y las rutinas de servicio a la interrupción desde el punto de vista del software.<br />
Éstos son aspectos de muy bajo nivel, relacionados directamente con el hardware y por eso se ubican en la primera capa del software de E/S del Sistema Operativo.<br />
<br />
== Controladores de dispositivo o Drivers ==<br />
<br />
Los Controladores de dispositivo o Drivers son componentes software especializados en comunicarse con un determinado dispositivo. En general son proporcionados por los fabricantes del hardware, que conocen los detalles específicos de los dispositivos que fabrican. El Sistema Operativo se comunica con ellos utilizando un lenguaje "estándar", independiente del dispositivo, y es el propio Driver el que interpreta "a su manera" las órdenes que recibe del Sistema Operativo para traducirlas al lenguaje de la Controladora hardware que se comunica con el propio dispositivo.<br />
Por cuestiones de rendimiento y eficiencia suelen ejecutarse en modo privilegiado (modo kernel) y por tanto son componentes software críticos para el Sistema Operativo. Un fallo de programación o un error en un Driver puede detener o dañar gravemente el estado de ejecución de un sistema. Por este motivo suelen supervisarse estrechamente por el Sistema Operativo las tareas de implantación de nuevos Controladores, de manera que éstos deben de verificar una serie de condiciones y aspectos de diseño concretos.<br />
<br />
== E/S independiente del dispositivo ==<br />
<br />
El "lenguaje estándar" al que se hace referencia en el apartado anterior se refiere al modo en el que el propio Sistema Operativo interactúa con los Drivers a petición de los programas de aplicación. Esta pieza fundamental que interconecta esos dos aspectos es el software de E/S independiente del dispositivo. Los aspectos controlados en este nivel son los siguientes:<br />
<br />
* '''Interfaz uniforme con los drivers de los dispositivos''': El modo en que el Sistema Operativo se comunica con los Drivers debe ser lo más uniforme y genérico posible, de modo que sea fácil comunicarse con los dispositivos de un modo "universal". Para ello se estandariza el mecanismo de comunicación (protocolo) de modo que se pueda añadir nuevos drivers sin necesidad de cambiar la forma en la que el Sistema Operativo dialoga con ellos.<br />
<br />
[[Archivo:5-13.jpg]]<br />
<br />
En este gráfico se muestra, en la parte derecha, como mediante una estructura, interfaz, de comunicación uniforme es más sencillo integrar los controladores de dispositivo (drivers) en el Sistema Operativo, mejorando la estabilidad y flexibilidad del mismo<br />
<br />
* '''Gestión de los búffers''': Otra de las tareas de esta capa es gestionar los búffers, o memorias intermedias, en la memoria principal que se encargan de acumular los datos leídos (o que se van a escribir) en un dispositivo.<br />
<br />
[[Archivo:5-14.jpg]]<br />
<br />
Gráfico ilustrativa del uso de búffers de lectura en la memoria principal. Estos búffers almacenan los datos que se van leyendo del dispositivo. Vemos en la figura que se están utilizando búffers en espacio de kernel y espacio de usuario. Las lecturas se hacen en primer lugar al espacio de kernel, modo en el cual se puede realizar el acceso al dispositivo, y luego se copian al espacio de usuario, donde las aplicaciones pueden leer sus datos. En la figura de la derecha se ilustra la técnica de doble búffer, el cual se utiliza para que mientras se copian datos de búffer de kernel al del usuario puedan seguir recibiéndose datos del dispositivo, para ello se utiliza otro búffer del kernel.<br />
<br />
* '''Informar de los errores''': El reporte de errores de las capas bajas se intercepta en la capa de E/S independiente del dispositivo dónde serán tratados.<br />
* '''Asignación y liberación de dispositivos dedicados''': Los procesos en ocasiones necesitan un acceso exclusivo a los dispositivos. Esta capa se encarga de gestionar este acceso, asignando y liberando los dispositivos a los procesos<br />
* '''Proporcionar un tamaño de bloque independiente del dispositivo''': El tamaño de bloque físico de los dispositivos de tipo bloque, como los discos, está predefinido en el hardware. Sin embargo para el Sistema Operativo suele ser más adecuado trabajar con tamaños de bloque que son múltiplos del tamaño de bloque físico (usualmente 512 bytes), de modo que las lecturas de bloques desde el punto de vista del Sistema Operativo (bloques lógicos) en realidad se traducen en órdenes de lectura de varios bloques físicos para el dispositivo. Por la propia naturaleza de los discos y su funcionamiento suele ser mucho más eficiente leer o escribir varios bloques físicos en cada operación de E/S, según el tamaño de bloque lógico, que hacerlo directamente leyendo o escribiendo en unidades de bloque físico (512 bytes). Esto se debe a que los retrasos de posicionamiento de la cabeza de lectura/escritura del disco son mucho mayores que los tiempos de transferencia de los bloques, por tanto, es más eficiente leer varios bloques físicos a la vez que hacerlo de uno en uno.<br />
Por ejemplo: Si tenemos bloques lógicos de 4KB, cada lectura de un bloque lógico de disco corresponderá con 8 lecturas de bloque físico (512 bytes x 8 = 4KB)<br />
Además esto permite que se puedan definir tamaños de bloque lógico diferentes (4KB, 8KB, 16KB), lo cual es útil para optimizar el rendimiento en función del tipo de utilización que el Sistema Operativo hará de los datos en el dispositivo (por ejemplo, para sistemas que manejen archivos grandes es más adecuado el uso de un bloque lógico grande)<br />
<br />
== E/S en espacio de usuario ==<br />
<br />
Y para terminar, en la parte más alta (abstracta) del modelo de capas nos encontramos con la E/S en espacio de usuario. Esta es la capa correspondiente al punto de vista que las aplicaciones y usuarios tienen del sistema de E/S. Por tanto consistirá en una serie de librerías (API, Application Programming Interface) que definen el modo para acceder a los dispositivos desde un punto de vista independiente de dispositivos. Por tanto, a la hora de utilizar un programa o escribir un programa de aplicación, el usuario no debe de preocuparse de los detalles del dispositivo, ni de aspectos de denominación del mismo, ni de manejo de los búffers, ni del reporte de errores, etc., ya que éstos son aspectos gestionados por la capa inmediatamente inferior (E/S independiente del dispositivo) que a su vez se comunica con la capa de Drivers de dispositivo.<br />
Ejemplo: A la hora de mandar un documento a la impresora simplemente invocamos esa función en un programa o en una librería de funciones, si estamos programando. No somos realmente conscientes de que existe un proceso, dentro del E/S en espacio de usuario, que se encarga de gestionar realmente la asignación de la impresora a los procesos que la necesitan. Este proceso es el servicio o demonio de spool, que gestiona la cola de documentos de la impresora. Este es otro ejemplo de lo que esta capa realiza, poniendo a disposición de usuarios y programadores un modelo cómodo y sencillo de utilizar los dispositivos de E/S<br />
<br />
[[Archivo:5-16.jpg]]<br />
<br />
En resumen, en este gráfico vemos las capas del sistema de E/S y su interacción<br />
<br />
= Referencias =<br />
<br />
== Búfer Caché ==<br />
http://www.tldp.org/pub/Linux/docs/ldp-archived/system-admin-guide/translations/es/html/ch07s06.html<br />
<br />
Ilustraciones de A.S. Tanenbaum distribuídas con licencia [https://creativecommons.org Creative Commons]<br />
<br />
[[Xestión de E/S|Volver]]<br />
<br />
JavierFP 13:10 04 dec 2018 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Administraci%C3%B3n_de_Dispositivos_y_Sistemas_de_Archivos_en_GNU/Linux&diff=65226Administración de Dispositivos y Sistemas de Archivos en GNU/Linux2018-12-04T16:52:13Z<p>Javierfp: </p>
<hr />
<div>[[Gestión de Dispositivos de Almacenamiento]]<br />
<br />
[[Creación de Sistemas de Archivos]]<br />
<br />
[[Montaje Sistemas de Archivos]]<br />
<br />
[[Tareas de explotación de Sistemas de Archivos]]<br />
<br />
[[Linux|Volver]]</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Sistemas_de_Arquivos._Fundamentos_te%C3%B3ricos&diff=65225Sistemas de Arquivos. Fundamentos teóricos2018-12-04T15:17:47Z<p>Javierfp: /* Directorios */</p>
<hr />
<div>= Sistemas de Archivos =<br />
<br />
== Definición ==<br />
<br />
Como elemento estructural clave de los Sistemas Operativo, el concepto de Sistema de Archivos está relacionado con una abstracción accesible y manejable de cara al usuario. Por encima de las complejidades inherentes a los dispositivos y al sistema de Entrada y Salida, el usuario final dispone de una visión de alto nivel y uniforme de los recursos de almacenamiento secundario.<br />
<br />
Independientemente de la base de almacenamiento subyacente, disco duro, disco óptico, dispositivo de estado sólido, pendrive, cinta, etc., la visión que el usuario tiene de los recursos de almacenamiento es la misma; basada en una estructura jerárquica de directorios y archivos.<br />
<br />
Las estructuras y conceptos claves, relacionados con los Sistemas de Archivos son los siguientes:<br />
<br />
== Archivo ==<br />
<br />
Un archivo es un elemento de información abstracto. Los archivos son elementos identificables de forma única en el Sistema de Archivos. La manera de identificar ese elemento depende del contexto:<br />
* Para un '''usuario''' un archivo o directorio se identifica mediante su path o ruta absoluta, es decir, un identificador textual único que contiene la secuencia de directorios en el sistema de archivos a los que es necesario acceder para llegar al elemento en cuestión, más el nombre del propio elemento.<br />
* Para el propio '''sistema operativo''' todo archivo o directorio se identifica mediante un identificador numérico, cuando éste está siendo utilizado por algún proceso. Además todo archivo o directorio tiene asociados un conjunto de '''metadatos''', o atributos, que son utilizados por el sistema de archivos para la gestión del elemento.<br />
<br />
Asociados a los archivos encontramos los programas que permiten procesar la información contenida en ellos. Por ejemplo, algunas asociaciones podrían ser:<br />
<br />
* archivo de texto '''odt''' -> LibreOffice Writer (o cualquier procesador de textos que interprete el formato .odt)<br />
* archivo '''pdf''' -> Visor de Documentos (o cualquier otro programa que interprete el formato .pfd)<br />
* archivo '''html''' -> Navegador Web Firefox (o cualquier otro navegador)<br />
<br />
La extensión de un archivo es por tanto un elemento importante a la hora de asociar el tipo de formato de un archivo con el programa utilizado para su procesamiento. Debemos tener en cuenta lo siguiente:<br />
<br />
* Puede haber un programa por defecto asociado a un tipo de archivo en el sistema. Esto es un aspecto de configuración del sistema operativo y es posible que se pueda modificar para que sea otro programa el encargado, por defecto, de abrir el tipo de archivo en cuestión.<br />
* La extensión de un archivo es un identificador, a la derecha del último carácter "." (punto) en el nombre del archivo. Por ejemplo: carta. '''odt''', index. '''html''', nominas. '''pdf'''<br />
<br />
== Directorio ==<br />
<br />
Un directorio es un tipo especial de archivo cuyo fin es dotar de estructura organizativa al sistema de archivos. El paradigma de implementación en los sistemas de archivos actuales es el de '''estructura de árbol invertido''' de anidamiento arbitrario.<br />
<br />
== Metadatos o Atributo ==<br />
<br />
Información relacionada con los archivos y directorios que el sistema de archivos necesita para su gestión. En el caso de GNU/Linux se utilizan estructuras de metadatos denominadas nodos-i, o i-nodos, de las cuales se hablará más adelante.<br />
<br />
== Path o Ruta ==<br />
<br />
Identificador textual único de cada elemento del sistema de archivos, archivo o directorio. Desde el punto de vista del usuario es el elemento principal para la localización e identificación de éstos. Un path o ruta es un identificador único del camino a seguir para poder localizar un elemento del sistema de archivos.<br />
<br />
Por ejemplo, la ruta '''/etc/apt/sources.list''', identifica el archivo '''sources.list''', dentro del directorio apt, que a su vez reside dentro del directorio etc, el cual se encuentra en la raíz del sistema de archivos<br />
<br />
* /<br />
** etc<br />
*** apt<br />
**** sources.list<br />
<br />
= Objetivos =<br />
<br />
El sistema operativo utiliza los Sistemas de Archivos como elemento estructural de organización y despliegue de la información en dispositivos de almacenamiento secundario. Estos dispositivos son variados y están construidos sobre distintas tecnologías, como discos duros, unidades ópticas, unidades flash, etc.<br />
<br />
Teniendo en cuenta la naturaleza de los recursos de almacenamiento gestionados por los Sistemas de Archivos, los objetivos principales que éstos deben proporcionar son:<br />
<br />
* '''Implementación de los conceptos de Archivo y Directorio'''<br />
* '''Uniformidad de nombres y rutas'''<br />
* '''Gestión del espacio libre en el dispositivo'''<br />
* '''Gestión del espacio usado por archivos en el dispositivo'''<br />
* '''Eficiencia en la gestión del espacio'''<br />
* '''Consistencia de Archivos y Directorios'''<br />
* '''Seguridad de acceso para Archivos y Directorios'''<br />
* '''Rendimiento y eficiencia en uso de los dispositivos'''<br />
* '''Sencillez y ausencia de errores'''<br />
* '''Interfaz amigable'''<br />
<br />
= Características de archivos y directorios =<br />
<br />
== Introducción ==<br />
<br />
Para poder gestionar de un modo eficiente y general los dispositivos de almacenamiento secundario se utilizan los Sistemas de Archivos. Existen 2 conceptos estructurales centrales que ayudan a implementar los Sistemas de Archivos, los archivos y directorios.<br />
Los archivos almacenan la información, tanto programas como datos utilizados por los mismos, de un modo homogéneo, transparente y extensible. Los directorios ayudan a mantener una estructura de acceso y visualización del Sistema de Archivos que lo haga fácilmente comprensible y accesible.<br />
La información en un Sistema de Archivos se organiza mediante una '''estructura jerárquica''', con forma de árbol invertido, cuya raíz está en el punto más elevado de la jerarquía. Llamaremos a esta estructura '''Árbol de Directorios''', la cual se despliega en anchura y profundidad de un modo arbitrario y recursivo. Un directorio puede contener archivos o directorios anidados en él. De este modo la estructura puede crecer en niveles de un modo ilimitado.<br />
<br />
Por tanto y según lo anterior, para hacer referencia a un archivo o directorio, es necesario conocer su ubicación dentro del Árbol de Directorios. Para este fin se utilizan las '''rutas o paths''', las cuales son cadenas de texto, separadas por caracteres tipográficos especiales (/ en Linux, \ en Windows) que indican la posición exacta de un archivo o directorio en el árbol. Existen 2 tipos de rutas o paths:<br />
<br />
* '''Absoluto''': Indica toda la secuencia en orden, desde la raíz, que es necesario recorrer para llegar a un archivo o directorio concreto<br />
* '''Relativo''': Indica la secuencia en orden, desde un directorio predefinido, directorio actual o directorio de trabajo, que es necesario recorrer para llegar a un archivo o directorio concreto<br />
<br />
== Archivos ==<br />
<br />
Un archivo es una abstracción utilizada por el sistema operativo, utilizada para representar un elemento de información persistente que podrá ser accedido y modificado de un modo, a priori, indeterminado. Es habitual, que los contenidos y estructuras de un archivo estén relacionados con algún programa que accederá a los contenidos del mismo. Sin embargo, para el sistema operativo, un archivo no es más que una secuencia de bytes, sin orden ni estructura predefinidas. Esta simplificación permite, que los archivos sean gestionados por el sistema operativo de un modo flexible, eficiente y homogéneo. Según esto, para el sistema operativo los contenidos y estructura del archivo son irrelevantes, simplemente proporcionará a los programas de aplicación un modo de acceso y una serie de funciones genéricas de manejo del archivo. Funciones como:<br />
<br />
* '''Apertura'''<br />
* '''Lectura'''<br />
* '''Escritura'''<br />
* '''Renombrado'''<br />
* '''Cierre'''<br />
* '''Borrado'''<br />
<br />
serán accesibles a los programas de aplicación a través de APIs de programación, que efectuarán las correspondientes llamadas al sistema.<br />
<br />
Además de los propios contenidos del archivo, es decir, la información semánticamente relevante almacenada en los mismos, se dispone de los denominados '''metadatos o atributos''' asociados al archivo. Éstos son elementos informativos utilizados por el sistema operativo para gestionar el archivo de un modo coherente y seguro. Por ejemplo, metadatos podrían ser:<br />
<br />
* '''Fechas de creación o modificación'''<br />
* '''Usuario propietario del archivo'''<br />
* '''Modo de acceso (lectura, escritura, lectura/escritura)'''<br />
* '''Enlaces que apuntan al archivo'''<br />
* '''Máscaras de permisos'''<br />
<br />
y un largo etc., que dependerá en gran medida del tipo del Sistema de Archivos considerado<br />
<br />
== Gestión del espacio libre en el dipositivo ==<br />
<br />
La base de almacenamiento del Sistema de Archivos (SA) es un dispositivo de de almacenamiento secundario (disco, unidad óptica, flash drive, etc.). Un aspecto fundamental gestionado por el SA es el espacio de almacenamiento libre del dispositivo. Al ser estos dispositivos de tipo bloque la gestión de espacio libre estará relacionada con la identificación de qué bloques de dispositivo están libres, es decir, disponibles para ser asignados a nuevos archivos y directorios del SA.<br />
<br />
Un sistema de gestión muy utilizado del espacio libre es el conocido como '''mapa de bits'''. Un mapa de bits es una estructura en la que se asigna un bit a cada bloque de almacenamiento del dispositivo. Cada uno de estos bits puede estar a 0, indicando que el bloque está disponible, es decir libre, o estar a 1, lo cual indicaría que ese bloque forma parte de la asignación de espacio de almacenamiento asociada a algún archivo dentro del SA.<br />
<br />
Otra técnica de gestión de espacio libre es la de '''lista enlazada de números de bloques libres'''. En esta aproximación se almacena una lista de bloques de disco que almacenan números de bloques libres.<br />
<br />
Las estructuras de gestión de espacio libre son mantenidas por el SA en zonas reservadas del dispositivo que se crean durante el proceso de formateo y creación del SA.<br />
<br />
En la siguiente figura podemos ver la gestión de bloques libres utilizando '''lista enlazada (figura a) y mapa de bits (figura b)'''<br />
<br />
[[Archivo:bitmap.png]]<br />
<br />
== Directorios ==<br />
<br />
Los directorios '''son un tipo especial de archivos que se utilizan para almacenar listas de archivos y otros directorios'''. Se utilizan para implementar la estructura jerárquica de directorios del Sistema de Archivos. Un directorio, por tanto, no es más que una lista que asocia nombres de archivos y directorios con elementos que permiten al Sistema de Archivos localizar los contenidos del mismo en el dispositivo de almacenamiento.<br />
<br />
En el caso de Linux, una entrada de directorio asocia un nombre de archivo o directorio con un número de '''i-nodo''', una estructura del Sistema de Archivos que permite acceder a los metadatos del archivo y directorio, a través del cual se puede acceder al mismo en el soporte de almacenamiento correspondiente.<br />
<br />
[[Archivo:dirlinux.jpg]]<br />
<br />
Otros sistemas como MS-DOS y Windows utilizan la propia entrada de directorio para almacenar la metainformación (metadatos) del archivo o directorio<br />
<br />
[[Archivo:dirmsdos.jpg]]<br />
<br />
Veremos un poco más adelante la estructura de un i-nodo (o nodo-i) utilizado en los Sistemas de Archivos de UNIX y Linux<br />
<br />
Existen, como en el caso de los archivos, una serie de funciones que pueden ser invocadas, vía API, por los programas de aplicación para acceder a los directorios del Sistema de Archivos. Algunas son:<br />
<br />
* '''Apertura'''<br />
* '''Lectura'''<br />
* '''Escritura'''<br />
* '''Cierre'''<br />
* '''Borrado'''<br />
<br />
== Gestión de la asignación de espacio de almacenamiento ==<br />
<br />
'''Un aspecto fundamental a gestionar por parte de los Sistemas de Archivos (SA) es la asignación de espacio de almacenamiento asociado a archivos y directorios'''. Como hemos visto, un archivo es un conjunto de información persistente. En consecuencia, habrá un soporte de almacenamiento de datos subyacente: el dispositivo de almacenamiento secundario sobre el que se despliega el SA.<br />
<br />
'''Cada archivo''', que debe ser almacenado en el soporte de almacenamiento secundario gestionado por el sistema de archivos, '''constará de un conjunto de bloques''', los cuales son elementos fundamentales de información en el dispositivo. Para poder localizar los datos asociados a un archivo o directorio en el dispositivo, a través de la identificación de los bloques asociados al mismo, el sistema de archivos debe de gestionar datos al respecto, es decir, metadatos, de estos elementos.<br />
<br />
A la hora de determinar el modo en que se gestionan la asignación de bloques de dispositivo para almacenamiento de datos de un archivo o directorio, existen varias alternativas, siendo las más utilizadas las descritas a continuación<br />
<br />
=== Mediante listas enlazadas. Tablas FAT ===<br />
<br />
En esta modalidad se parte de la '''entrada del archivo o directorio''' del directorio en el que se encuentra el elemento (archivo o directorio). Esa entrada debe contener la información del '''número del primer bloque''' de datos del archivo o directorio en el dispositivo. Partiendo de ese primer bloque se consulta una tabla en memoria, denominada tabla '''FAT (File Allocation Table)''', a partir de la cual determinamos la cadena, o lista enlazada, de bloques consecutivos en el dispositivo en el que se encuentran los datos del archivo o directorio.<br />
<br />
La tabla FAT contiene una entrada para cada bloque lógico asociado al dispositivo, en esa entrada se encuentra el '''número del siguiente bloque lógico''' de almacenamiento asociado al archivo o directorio procesado. Siguiendo esa lista de bloques consecutivamente llegaremos al último bloque de datos, el cual estará marcado con un número de bloque no asignable, normalmente indicado con el número -1, indicador de que se ha alcanzado el fin de archivo '''EOF''' (End Of File) y que la cadena de bloques ha finalizado.<br />
<br />
Un ejemplo lo podemos ver más abajo cuando se habla del Sistema de Archivos FAT de Windows<br />
<br />
[[Archivo:fatfs.jpg]]<br />
<br />
=== Mediante índices. I-nodos ===<br />
<br />
Otro sistema de gestión de la asignación de bloques lógicos de almacenamiento a archivos y directorios es mediante estructuras indexadas.<br />
<br />
Un claro ejemplo de esta modalidad son los Sistemas de Archivos utilizados por '''UNIX y GNU/Linux''' que se basan en el concepto de '''i-nodo''' (nodo índice). Un i-nodo es un elemento de metadatos asociado a un archivo o directorio a través de la entrada del directorio descriptiva del elemento en cuestión. Ese elemento almacena toda la información del archivo o directorio.<br />
<br />
'''Todo archivo o directorio en un sistema de archivos en Linux tiene asociado un i-nodo'''. A través de ese elemento el sistema de archivos puede conocer los detalles necesarios para gestionar los recursos asignados al archivo o directorio. El i-nodo consta de una serie de elementos informativos almacenados en secuencia.<br />
<br />
* En los primeros elementos se almacenan los metadatos del archivo, como '''fechas, propietario, grupo del propietario, modo, permisos''', etc.<br />
* A continuación se almacenan las '''direcciones de bloques en disco''' que contienen datos del archivo. Habitualmente se almacenan sobre unas '''10 de esas direcciones en el propio i-nodo''', de modo que, si el tamaño de bloque son, por ejemplo, 4KB, podríamos direccionar de este modo archivos de 10x4=40KB, pero...¿qué pasa con archivos más grandes?. En este caso necesitamos utilizar los 3 últimos elementos del i-nodo, '''los apuntadores indirectos simple, doble y triple'''<br />
* '''Apuntador indirecto simple''': Almacena la dirección de un bloque de disco que contiene direcciones de bloques de disco del archivo<br />
* '''Apuntador indirecto doble''': Almacena la dirección de un bloque de disco que contiene apuntadores a direcciones de bloque de disco que contienen direcciones de bloque del disco del archivo<br />
* '''Apuntador indirecto triple''':Almacena la dirección de un bloque de disco que contiene apuntadores a direcciones de bloque de disco que contienen bloques con direcciones que apuntan a direcciones de bloque del disco del archivo<br />
<br />
De este modo pueden ubicarse bloques de archivos de hasta TB de tamaño<br />
<br />
[[Archivo:nodoi.jpg]]<br />
<br />
Los i-nodos se almacenan en la partición del dispositivo sobre la que se crea el sistema de archivos, en una zona reservada para ello. Durante el proceso de formateo del volumen físico se reserva una zona para albergar estas estructuras definitorias de los archivos y directorios.<br />
<br />
Cada i-nodo tiene asociado un identificador numérico único, de este modo cada archivo o directorio es gestionado por un único i-nodo. Este es el motivo por el cual las entradas de directorio en sistemas de archivos que utilizan i-nodos solo contienen el nombre del archivo y el numero de su i-nodo asociado. Una vez localizado el i-nodo toda la información del archivo o directorio puede ser localizada a partir de éste.<br />
<br />
=== Estructura del sistema de archivos en una partición de disco ===<br />
<br />
Un Sistema de archivos no es más que una '''estructura de almacenamiento normalizado de archivos y directorios en un volumen de almacenamiento de datos asociado a un dispositivo de bloques''' (disco duro, pendrive, unidad óptica, dispositivo SSD, etc.).<br />
<br />
Para poder desplegar un sistema de archivos necesitamos una partición dentro de un dispositivo de bloques. Dentro de la partición, durante el proceso de formateado del sistema de archivos, se crearán todas las estructuras de datos necesarias para dar soporte al almacenamiento de archivos, como por ejemplo:<br />
<br />
* '''Superbloque''': Zona en la que se indica el tipo y datos del propio sistema de archivos<br />
* '''Zona de gestión del espacio libre:''' en el que se almacena por ejemplo el mapa de bits<br />
* '''Bloque de arranque''', utilizado para arrancar el sistema operativo, en caso de que sea un sistema de archivos asociado a un sistema operativo<br />
* '''Zona para almacenamiento de i-nodos'''<br />
* '''Zona de almacenamiento de archivos'''<br />
<br />
[[Archivo:particion.jpg]]<br />
<br />
=== FAT y NTFS ===<br />
<br />
En el caso de Windows, que utiliza actualmente '''NTFS''' como único Sistema de Archivos soportado, la orientación es ligeramente diferente. En este caso los directorios contienen parte de la información de metadatos del archivo. En el caso de '''FAT''' (File Allocation Table), ver entrada de directorio de figura anterior, se almacenan, además del nombre y extensión, otros atributos, como: fechas, tamaño...<br />
y un apuntador al primer bloque del archivo en el disco. A partir de este número de bloque, mediante una tabla ubicada en RAM, la FAT, se pueden encontrar el resto de bloques que constituyen el archivo, simplemente siguiendo una cadena de enlaces definidos en la tabla FAT.<br />
<br />
[[Archivo:fatfs.jpg]]<br />
<br />
NTFS no utiliza una tabla FAT, ya que ésas tienen el inconveniente de que ocupan en memoria un espacio proporcional al número de bloques lógicos del disco. Si el disco es muy grande, o el tamaño de bloque muy pequeño, la tabla FAT puede utilizar cantidades ingentes de memoria en RAM. Otro inconveniente es que las búsquedas de bloques tienen que seguir una cadena secuencial de localización en la FAT, por lo que es un sistema lento en general. Por estos motivos las FAT se consideran obsoletas y poco fiables.<br />
<br />
'''NTFS''' utiliza otra estructura para gestionar la ubicación de archivos y directorios en disco y sus metadatos. Esa estructura es la '''MFT''' (Master File Table), la cual es compleja, aunque ofrece características de gestión del Sistemas de Archivos muy potentes:<br />
<br />
* '''Transaccionalidad (journaling)'''<br />
* '''Soporte para ACL (Listas de Control de Acceso)'''<br />
* '''Cifrado del Sistema de Archivos'''<br />
* '''Cuotas'''<br />
<br />
== Características avanzadas de Sistemas de Archivos ==<br />
<br />
* '''Transaccionalidad (journaling)''': Esta característica, cuando está soportada, permite utilizar las operaciones del Sistema de Archivos, como creación, borrado y actualización de los metadatos de archivos y directorios, como si se tratara de operaciones transaccionales. Esto quiere decir que una operación de esta naturaleza no se confirma hasta que esté completamente terminada y, en caso de que ocurra algún error durante su ejecución, el Sistema de Archivos revierte su estado al momento inmediatamente anterior al inicio de la operación. En este aspecto son similares a los procesos de control transaccional de las bases de datos.<br />
Para implementar esta característica se utiliza un archivo de '''journal (bitácora)''', en el que se van anotando las operaciones a realizar, eliminándose del mismo cuando esta se complete. Si ocurre un problema y el sistema, por ejemplo, se reinicia, habrá anotaciones en la bitácora que indicarán aquellas operaciones que han quedado sin terminar en el momento de la falla. De este modo el sistema puede revertir, deshacer, esas operaciones, dejando al Sistema de Archivos en un estado consistente.<br />
<br />
* '''Cifrado''': Consistente en la posibilidad de cifrar el contenido del Sistema de Archivos para que solamente el usuario propietario de los archivos pueda acceder a su contenido al disponer de la clave de cifrado/descifrado correspondiente.<br />
<br />
* '''Compresión''': Capacidad de almacenar los archivos y directorios comprimidos en el dispositivo de almacenamiento. Esta característica, aunque es transparente para el usuario, suele empeorar el rendimiento del Sistema de Archivos en las operaciones de lectura y escritura.<br />
<br />
== Sistemas de Archivos en Sistemas Operativos actuales ==<br />
<br />
=== FAT ===<br />
<br />
Sistema de Archivos de MS-DOS y versiones de Windows no basadas en tecnología NT. Utiliza una tabla FAT para acceder a los bloques de archivo, lo que lo hace lento e ineficiente. Además no posee control transaccional del Sistema de Archivos y está limitado en cada versión por el número de bits de su arquitectura (FAT16, FAT32...). Sin embargo, debido a su sencillez y amplia difusión, sobrevive como Sistema de Archivos compatible con todas las arquitecturas de sistema operativo y por ser utilizado también en dispositivos de almacenamiento externo y multimedia.<br />
<br />
=== NTFS ===<br />
<br />
Sistema de Archivos de las versiones de Windows NT. Ha evolucionado a lo largo del tiempo y de sus versiones. Es un sistema de gestión de archivos y directorios muy avanzado y con amplio soporte de características<br />
<br />
* Transaccionalidad<br />
* Cifrado<br />
* Compresión<br />
* Gestión avanzada de permisos<br />
* Cuotas<br />
<br />
Para discos muy pequeños (por debajo de unos GB de capacidad) no es recomendable, debido a que las estructuras de control de NTFS (principalmente la MFT) ocupan bastante espacio en el disco<br />
<br />
=== ext2, ext3 y ext4 ===<br />
<br />
Diferentes versiones del Sistema de Archivos ext (extended Filesystem)<br />
<br />
* '''ext2''': rápida, ligera y eficiente. No tiene soporte transaccional, lo que puede suponer un problema para la consistencia del Sistema de Archivos. Se considera obsoleta en genera <br />
* '''ext3''': derivada de ext2, con soporte para características avanzadas, como la transaccionalidad (journaling) del Sistema de Archivos<br />
* '''ext4''': última versión liberada. Deriva de ext3, a la que añade nuevas características y extensión de los límites en el número de archivos y tamaño de los mismos soportado por el Sistema de Archivos<br />
<br />
=== Otros: reiserfs, xfs, jfs, hfs+===<br />
<br />
== Sistemas de Archivos en Red ==<br />
<br />
=== NFS ===<br />
<br />
Network File System. Permite compartir directorios en red de modo que sean públicamente accesibles y de un modo independiente al cliente (Linux, Windows, Mac...). Permite compartir en LAN, o bien en WAN (a través de Internet), por tanto la seguridad debe de ser un aspecto importante a considerar. Utiliza arquitectura cliente/servidor, es decir necesitaremos los módulos correspondientes para acceder y/o publicar recursos NFS. Existen versiones libres y gratuitas de clientes y servidores NFS para Linux, Windows y Mac.<br />
Es importante considerar que versión de NFS se está utilizando. En la actualidad conviven NFSv3 y NFSv4, siendo incompatibles entre sí.<br />
<br />
=== FTP ===<br />
<br />
File Transfer Protocol. Protocolo de transferencia de archivos en redes TCP/IP. Fue uno de los primeros protocolos de aplicación implementados en redes TCP/IP. Por este motivo, al ser tan antiguo, presenta características de seguridad obsoletas, que pueden ser solventadas con medidas de seguridad adicionales. Es simple, rápido y existe una amplia base de servidores y clientes disponibles para todas las plataformas.<br />
<br />
=== Samba ===<br />
<br />
Implementación libre de los protocolos de red SMB/CIFS de Microsoft. Desarrollado para hacer compatibles redes con clientes Windows y Linux. Un servidor Samba puede ser utilizado para compartir directorios e impresoras en redes con clientes Windows y Linux. También puede utilizarse como Controlador de Dominio de red, al estilo de los Controladores de Dominio de Microsoft (NT, o Active Directory).<br />
Su administración es compleja y requiere profundos conocimientos de redes y sistemas. Actualmente conviven las versiones Samba 3 y Samba 4, siendo esta última compatible con características de los dominios Active Directory, que hasta el momento no estaban soportadas.<br />
<br />
== Herramientas ==<br />
<br />
=== Recopilación de información del Sistema de Archivos ===<br />
<br />
En Windows disponemos de herramientas integradas para acceder a características y estadísticas de uso del Sistema de Archivos. Bien desde el Panel de Control, o bien, desde el propio explorador de archivos y las Herramientas Administrativas del Sistema.<br />
<br />
En Linux existen también herramientas en modo gráfico y modo consola. Algunos comandos relacionados:<br />
<br />
* '''df''': Obtención del espacio libre de un sistema de archivos<br />
* '''du''': Obtención del espacio utilizado por archivos y directorios del sistema de archivos<br />
* '''fsck''': File System Check, chequeo del sistema de archivos<br />
<br />
=== Creación de Sistemas de Archivos ===<br />
<br />
De nuevo existen herramientas de este tipo integradas en todos los sistemas. Desde el '''Administrador de Discos''' de Windows, el cual permite gestionar las particiones de los discos y creación de Sistemas de Archivos NTFS y FAT. En linux tenemos, en modo gráfico y consola, tanto en distribuciones instaladas como '''LiveCD''', herramientas de creación de Sistemas de Archivos. Algunos comandos relacionados:<br />
<br />
* '''fdisk''': Creación y gestión de particiones<br />
* '''cfdisk''': Creación y gestión de particiones, permite gestionar particiones en formato GPT, algo que fdisk no permite<br />
* '''mkfs''': Creación de sistemas de archivos<br />
<br />
=== Herramientas de monitorización, chequeo y reparación del Sistema de Archivos ===<br />
<br />
Pueden instalarse en cualquier sistema herramientas '''de terceros''', o bien utilizar herramientas '''integradas''', para obtener información sobre el estado de uso y salud del Sistema de Archivos y los dispositivos que lo soportan. Es importante controlar el estado de uso de recursos del Sistema de Archivos y su salud, es decir, si el soporte de almacenamiento, como por ejemplo un disco duro, está en buen estado y no se han registrado errores de funcionamiento, que podrían indicar un próximo punto de falla.<br />
<br />
Existen compilaciones de software, como por ejemplo '''HirensBoot''', o una LiveCD específica, así como herramientas de fabricantes de dispositivos que permiten hacer comprobaciones exhaustivas del estado y prestaciones del mismo.<br />
<br />
Ilustraciones de A.S. Tanenbaum distribuídas con licencia [https://creativecommons.org Creative Commons]<br />
<br />
[[Xeneralidades dos Sistemas Operativos|Volver]]<br />
<br />
JavierFP 16:31 03 dec 2018 (CET)</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Xesti%C3%B3n_de_E/S&diff=65201Xestión de E/S2018-12-04T12:12:57Z<p>Javierfp: </p>
<hr />
<div>== [[ Fundamentos da Xestión da E/S ]] ==<br />
javierfp 4 dec 2018<br />
<br />
== [[Algoritmos de Planificación do disco]] ==<br />
ricardofc 14 nov 2008<br />
<br />
[[Xeneralidades dos Sistemas Operativos|Volver]]</div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Csata.jpg&diff=65195Archivo:Csata.jpg2018-12-04T12:06:42Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:Disco-scsi.jpg&diff=65194Archivo:Disco-scsi.jpg2018-12-04T12:06:27Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-16.jpg&diff=65193Archivo:5-16.jpg2018-12-04T12:06:19Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-14.jpg&diff=65192Archivo:5-14.jpg2018-12-04T12:06:01Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-13.jpg&diff=65191Archivo:5-13.jpg2018-12-04T12:05:52Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-11.jpg&diff=65190Archivo:5-11.jpg2018-12-04T12:05:42Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-5.jpg&diff=65189Archivo:5-5.jpg2018-12-04T12:05:33Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-4.jpg&diff=65188Archivo:5-4.jpg2018-12-04T12:05:24Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-3.jpg&diff=65187Archivo:5-3.jpg2018-12-04T12:05:13Z<p>Javierfp: </p>
<hr />
<div></div>Javierfphttps://manuais.iessanclemente.net/index.php?title=Archivo:5-2.jpg&diff=65186Archivo:5-2.jpg2018-12-04T12:05:00Z<p>Javierfp: </p>
<hr />
<div></div>Javierfp