¿Cómo instalo, desinstalo o actualizo paquetes rpm?

Los paquetes rpm son archivos que llevan incluidos dentro de ellos todos los ficheros que componen un determinado programa. Internamente están comprimidos, pero nosotros sólo debemos pensar en ellos en términos de Instalación, Actualización, Borrado y Consultas. Dentro del rpm van los ficheros del programa a instalar, su descripcion, a que directorios van a ir instalados, scripts de auto-configuración en algunos casos, etc.

La sintaxis de rpm es rpm -acción nombre_del_paquete

Acciones:

  rpm -i  archivo   (instalar)
  rpm -e  paquete   (desinstalar)
  rpm -u  paquete   (actualizar)
  rpm -qi paquete   (pedir info)

Ejemplos:

  rpm -i  Par-1.50-1.i386.rpm
  rpm -e  Par
  rpm -u  Par
  rpm -qi Par

Supongamos el fichero programa-1.0.rpm que no tenemos instalado y que acabamos de bajar de Internet. Procedemos a su instalación:

  rpm -i programa-1.0.rpm

Tras eso el programa estará instalado en nuestro Linux y podremos ejecutarlo y usarlo normalmente. Tal vez nuestro problema es que no sabemos como se llama el ejecutable y los demás ficheros de configuración que le acompañan. Para solucionar eso hacemos una consulta (query) del paquete ya instalado:

  rpm -ql programa

La acción -ql significa “query list”, y nos mostrará en pantalla la lista de ficheros instalados de este programa y sus directorios destinos. Si por ejemplo deseamos ver sólo los fichero sean instalados en los directorios bin (los ejecutables) podemos hacer uso de grep, la herramienta de Linux que sólo nos mostrará aquellas líneas que contengan una cadena determinada:

  rpm -ql programa | grep bin

Esto nos mostrará sólo los ficheros de “programa” que hayan sido instalados en directorios bin.Si queremos saber que hace un paquete instalado, podemos verlo con la opción “query info” (-qi):

  rpm -qi programa

Como ejemplo, veamos la salida para el paquete fetchmail de Linux:

  Name        : fetchmail
  Relocations : (not relocateable)
  Version     : 5.0.0
  Vendor      : Red Hat Software
  Release     : 1
  Install date: dom 30 may 1999 16:00:12 CEST
  Group       : Applications/Internet
  Size        : 565413
  Packager    : Red Hat Software http://developer.redhat.com/bugzilla
  Summary     : A remote mail retrieval and forwarding utility.
  Description : Fetchmail is a remote mail retrieval and forwarding utility intended
                for use over on-demand TCP/IP links, like SLIP or PPP connections.
                Fetchmail supports every remote-mail protocol currently in use on the
                Internet (POP2, POP3, RPOP, APOP, KPOP, all IMAPs, ESMTP ETRN) for
                retrieval.  Then Fetchmail forwards the mail through SMTP, so you can
                read it through your normal mail client.

Si el programa no nos gusta, la deinstalación es muy sencilla:

  rpm -e programa

Obviamente, no tenemos porqué instalar los programas para ver su contenido o información. Los podremos ver antes de la instalación insertando un comando p antes de la acción:

  rpm -qpi fichero.rpm
  rpm -qpl fichero.rpm

Si queremos ver la lista de RPMs instalados disponemos del comando “query all” (-qa):

  rpm -qa

Para verlo en formato pausado, podemos usar una tubería:

  rpm -qa | less

Es posible que tras un tiempo obtengamos la versión 2.0 del programa que ya disponemos instalado. En esto caso hay 2 opciones: bien eliminar el programa anterior (-e) e instalar este nuevo (-i), o, simplemente, actualizar el programa a la versión 2.0 con el comando -U (de Update):

  rpm -U programa-2.0.rpm

Por último, si al tratar de instalar un paquete rpm aparece el siguiente error:

  Data type X not supprted

Esto es debido a que nuestra versión de rpm es muy antigua, al menos más que el rpm que estamos tratando de instalar, y que este tiene algún tipo de compresión o elemento que nuestro rpm no entiende. Bastará entonces con actualizar nuestro ejecutable del RPM.Cabe decir que también existen front-ends al programa rpm, es decir, programas en modo gráfico (o texto) que realizan las acciones del programa RPM mediante pulsaciones nuestras del ratón. Es el front-end el que se encarga de pasarle a RPM los parámetros correctos para que se realice la acción pedida por el usuario. Entre estos programas tenemos glint, gnorpm, purp, kpackage, xrpm, etc.

¿Cómo se utilizan los empaquetadores-des/compresores?

Los ficheros tar no son ficheros comprimidos, sino empaquetados. Tar es un empaquetador, es decir, es algo parecido a un compresor como arj o zip, pero sin compresión. Se dedica a incluir todos los ficheros juntos en el mismo archivo, preservando las estructuras de directorios y permisos de los mismos. Como veremos, lo podremos comprimir gracias al programa GZip.
Hay 2 operaciones básicas con tar: empaquetado y desempaquetado. Si estamos en un directorio y queremos empaquetar todos los ficheros de este directorio y los que cuelgan de él, basta con ejecutar la orden:

  tar -cvf fichero.tar *
  c = compress  (más bien, empaquetar)
  v = verbose   (para que nos diga lo que hace)
  f = file      (empaquetar en un fichero)
  *             (empaquetar todos los ficheros, podría haber sido *.doc, etc.)

Si disponemos de un fichero .tar y queremos desempaquetarlo:

  tar -xvf fichero.tar
  x = eXtract   (desempaquetar).

También es posible listar los contenidos de un fichero .tar antes de desempaquetarlo, mediante la orden tar -tvf fichero.tar .Por otra parte, el ficheros con extensión gz son ficheros comprimidos. A diferencia de arj o zip, el contenido de un fichero GZ es un solo fichero, es decir, cuando comprimimos fichero.txt con este compresor (llamado gzip) obtenemos un fichero.txt.gz de tamaño mucho menor. Con GZ no es posible empaquetar ficheros, es decir, la compresión se realiza a un sólo fichero.

Para comprimir un fichero con gz, se utiliza el comando:

  gzip fichero

Para descomprimirlo:

  gunzip fichero.gz

La combinación de tar y gz es lo que permite el tener multiples ficheros comprimidos en un sólo archivo. Es decir, si empaquetamos un directorio con tar y luego comprimimos ese archivo tar con gz, obtenemos un tar.gz comprimido con múltiples ficheros.La compresión y descompresión es posible hacerla en 2 pasos (primero tar y luego usar gz) o bien usar el flag -z de tar para ello:

Compresión:

  tar -cvzf fichero.tar.gz *

Descompresion:

  tar -xvzf fichero.tar.gz

Otro formato que se ha puesto de moda es bzip2, con el mismo sistema de funcionamiento que Gzip, y cuyos nombres de ejecutable son bzip2 (comprimir) y bunzip2 (descomprimir). Este compresor obtiene mejor compresión que Gzip y su funcionamiento es igual de sencillo, aunque tarda mas en comprimir y utiliza mas recursos.Estos compresores/descompresores/empaquetadores son una gran y libre alternativa a formatos comerciales como zip, arj y rar, también disponibles para Linux (comandos zip, unzip, rar y unarj).

Para descomprimir ficheros arj mediante unarj, simplemente hace falta ejecutar el comando unarj x fichero.arj. El compresor es shareware y se debe obtener en la Web de sus programadores.

Zip es el programa destinado a hacer Linux capaz de leer y escribir los ficheros en formato .zip (generados por pkzip o winzip): Para ello tenemos los comandos zip e unzip, que nos permitiran comprimir y descomprimir ficheros sueltos, directorios completos, directorios con recursividad, etc:

Para comprimir todos los ficheros de un directorio en un zip:

  zip fichero.zip *

Para comprimir este directorio y todos los que cuelguen del mismo:

  zip -r fichero.zip *

La descompresión se realiza mediante unzip:

  unzip fichero.zip

El programa rar también es un buen compresor que podemos encontrar en diferentes formatos (rpm, deb, tar.gz) en Internet. Su uso es identico a la versión MSDOS:Comprimir:

  rar a fichero.rar *

Descomprimir:

  rar x fichero

Para más información sobre cualquiera de los des/compresores basta con consultar la página man del mismo, mediante “man comando“.

¿Cómo arranco directamente en XWindow?

En Linux es perfectamente posible pedir que el arranque del sistema se haga en modo gráfico, y que el login y password se introduzcan directamente en una ventana XWindow para la posterior carga del gestor de ventanas habitual que use dicho usuario.
Es decir, podremos identificarnos y aparecer directamente bajo X sin necesidad de ejecutar startx.

Para arrancar directamente en XWindow (o no hacerlo) todo el proceso de configuración gira en torno a cambiar el runlevel (o nivel de ejecución en que arranca Linux).

El runlevel es, dicho de una manera sencilla, el modo en que arranca Linux. Por defecto el runlevel suele ser el 2 ó el 3, es decir, arranque en modo texto o consola ó en modo gráfico. Para cada distribución suele haber una lista de runleves y sus significados, aunque casi se puede decir que son similares para todas ellas. Para Redhat, por ejemplo, la lista es la siguiente:

  # Porción del fichero /etc/inittab
  # Default runlevel. The runlevels used by RHS are:
  #   0 - halt (Do NOT set initdefault to this)
  #   1 - Single user mode
  #   2 - Multiuser, without NFS (The same as 3)
  #   3 - Full multiuser mode
  #   4 - unused
  #   5 - X11
  #   6 - reboot (Do NOT set initdefault to this)

Como puede verse, el arranque normal por defecto para que puedan acceder usuarios a Linux es 2 (si no tenemos red) o 3 si queremos usar servicios de red, siendo normalmente este el runlevel por defecto. Como puede verse, X11 tiene asignado el runlevel al 5. Si cambiamos el runlevel por defecto para que arranque en el 5, nos aparecerán directamente X Window.Para cambiar este runlevel por defecto hay que editar el fichero /etc/inittab, y acudir a la siguiente línea:

  id:3:initdefault:

El valor numerico antes de initdefault indica el runlevel de arranque por defecto. Si lo cambiamos de 3 a 5, la próxima vez que arranquemos Linux arrancará en X Window:

  id:5:initdefault:

Para que el proceso se ejecute correctamente debe tener instalado un gestor de arranque en runlevel 5, que es el programa encargado de pedir el login+passwd y arrancar el gestor de ventanas adecuado. Puede elegir entre xdm (el que viene por defecto con XWindow), kdm (version de kde del mismo) y gdm (versión aportada por gnome). Cada una de ellas dispone de ciertos ficheros de configuración o ejecutables para cambiar el fondo del login, el lenguaje, gestor de ventanas, etc. Consulte los ficheros en los paquetes relacionados.Haga “man runlevel” para mas información sobre runlevels.

En las últimas versiones de Redhat, el programa Xconfigurator le permite elegir si desea o no arrancar directamente en XWindow (él mismo modifica el runlevel por defecto) mediante una simple pregunta a la que se debe responder SI (Si desea arrancar en runlevel 5) o NO (si desea arrancar en runlevel 3). Esta pregunta se le suele realizar al finalizar la selección de resoluciones y antes de salir de Xconfigurator.

Una vez arranque en XWindow, puede volver a cualquier consola de texto mediante las teclas Ctrl+Alt+F1, Ctrl+Alt+F2, etc. (por defecto entre F1 y F6 tendrás 6 consolas de texto), y volver a XWindow en cualquier momento mediante Ctrl+Alt+F7 en adelante.

En algunas distribuciones puede ser necesario indicarle a inittab dónde está el gestor de runlevel 5 que debe arrancar:

Para xdm:

  #Run xdm in runlevel 5
  x:5:respawn:/usr/X11R6/bin/wdm -nodaemon

Para gdm:

  x:5:respawn:/etc/X11/prefdm -nodaemon

Estas líneas suelen ser automáticamente incluidas en el fichero por los rpm/deb instaladores de xdm, kdm y gdm. Consulte en la ayuda de dichos programas para más información.

Uso de la memoria RAM

Este tema, aunque no lo crea, también se relaciona con los procesos. Además, es una de las mayores diferencias con otros sistemas operativos.Apenas use el comando free usted verá algo como esto:

[lester@Centos lester]$ free
             total       used       free     shared    buffers     cached
Mem:        251960     246884       5076          0      16136     110072
-/+ buffers/cache:     120676     131284
Swap:       393552       3612     389940
[lester@Centos lester]$

Interpretemos esto: el comando nos devuelve información ordenada a partir del archivo /proc/meminfo. La primera línea de free muestra datos de la RAM instalada en el sistema, empezando por la total (256 MB, de los cuales más o menos 5 se usan para ocultar el kernel y algunas otras cosas); con aparentemente 246 MB usados, y sólo unos 5 MB libres. Esto es lo que a muchos usuarios nuevos (a nosotros incluídos) les hizo alguna vez sorprenderse. Ahora, sigamos leyendo hasta el final: hay aproximadamente 110 MB de memoria cacheada, es decir, con datos almacenados por si acaso. Esa cantidad de memoria en realidad está disponible si algún proceso la usa, pero si no, almacena librerías compartidas o accesos a directorios, lo que acelera su carga.

Es por esta razón que no hay que apagar de manera “incorrecta” la PC: gran parte del sistema de archivos puede estar abierto y cargado en la RAM, por lo que un Reset “duro” puede provocar la pérdida de datos. Esto se hace cada vez más difícil a medida que los sistemas de archivos de Linux mejoran, pero lo mejor siempre será tomarse la molestia de apagar con el comando halt -p o desde el modo gráfico.

Como siempre espero que les haya resultado de gran utilidad…

Salu2,

Lester Espinosa Martínez

Uso de pipes o tuberías

¿Recuerda el principio de estos tutoriales, donde dijimos que una de las virtudes de Unix es la modularidad? Bueno, lo que conecta entre sí todos estos pequeños programas o módulos son los pipes o tuberías. Se usa el símbolo | (en un teclado con mapeado español se obtiene con Alt Gr + 1) para representar un pipe entre un proceso y otro. Los pipes permiten que la información que da un comando esté disponible directamente para otro comando. ¿Ejemplos? Veamos:

[lester@Centos foo]$ rpm -qa | grep gnomeicu
gnomeicu-0.98.126-2mdk

Como ve, usamos el resultado del comando rpm -qa (mostrar la lista de todos los paquetes rpm) como entrada para el comando grep gnomeicu Resultado: buscamos dentro de la lista de todos los paquetes los que contuvieran la frase “gnomeicu”. Otro ejemplo:

[root@Centos foo]# cat /var/log/messages | less

Le mostrará el contenido del archivo de log messages (deberá conectarse como root). No hay límite a la cantidad de pipes que pueda usar. Ultimo ejemplo:

tar -cvf docs.tar docs/ | gzip -v docs.tar
docs.tar: 65.2% -- replaced with docs.tar.gz

Esto crea un archivo agrupado con el comando tar, y luego gzipea (comprime) ese archivo.

Espero que les haya resultado de gran utilidad…

Salu2,

Lester Espinosa Martínez

nice y renice

Estos programas permiten algo importante: cambiar la prioridad de un proceso. En Linux, los procesos corren con un número de importancia entre 19 (la menor) y -20 (la más alta). Los procesos con mayor prioridad tienen preferencia de procesamiento.

¿De qué puede servir esto? Bueno, suponga que quiere grabar un CD y seguir trabajando (suponga también que la PC puede hacer el trabajo). Podría iniciar el comando cdrecord con una prioridad alta, y despreocuparse. Para esto tendrá que conectarse como root, eso sí: un usuario común no puede elevar la prioridad a números negativos (recuerde que la máxima prioridad es -20):

[lester@Centos foo]$ nice -n 8 aterm &
[2] 5782
[1]   Done                    nice -n 8 aterm
[lester@Centos foo]$ nice -n -10 aterm &
[3] 5814
nice: no se puede establecer la prioridad: Permission denied
[3]+  Exit 1                  nice -n -10 aterm
[lester@Centos foo]$

Como ve, el uso de nice es simple: la opción -n número le permite cambiar el número de prioridad. Para cambiar la prioridad de un proceso que ya está corriendo, deberá usar el comando renice, con las mismas limitaciones que nice: un usuario común no puede elevar demasiado la prioridad de un proceso. Deberá conocer el PID del proceso que quiere modificar, y aprovecharemos esto para introducir el siguiente concepto a tratar: variables de shell:

[lester@Centos foo]$ nice -n 3 gvim &
[1] 6630
[lester@Centos foo]$ renice 4 $(/sbin/pidof gvim)
6631: prioridad antigua 3, nueva prioridad 4
[1]+  Done                    nice -n 3 gvim

A ver qué hicimos aquí. Primero iniciamos el editor de texto gvim con una prioridad de 3 y en segundo plano. Posteriormente le cambiamos la prioridad a cuatro, usando renice. Esta es la explicación simple, y deja varias cosas por comentar, que veremos inmediatamente. Pero antes, una aclaración: el comando renice sólo funcionará para procesos que el usuario pueda alterar (es decir, que él haya iniciado) y sólo para incrementar prioridades (es decir, para “quitarle importancia” al proceso. Conectándonos como root podremos además aplicar prioridades negativas, y cambiar el factor nice de usuarios (con la opción -u): todos los procesos de esos usuarios correrán por defecto con ese valor de nice.

Espero que les sea de gran utilidad…

Salu2,

Lester Espinosa Martínez

PIDs

Ha llegado el momento de hablar un poco más sobre los procesos y su creación. Como ya habrá notado, llamamos proceso a cualquier programa corriendo. En Unix, un proceso se inicia y puede dar nacimiento a otros, que son sus hijos, mediante lo que se conoce como forking o ramificación. Si conoce de biología, el forking es similar a la división celular: allí donde había un proceso hay una división, y quedan dos. Para ordenar esto y poder llamar a cada uno de los programas que corren, el sistema usa la tabla de procesos, en la que cada proceso lleva un número único, dado por el orden de aparición. El primer proceso es init, y de él se desprenden todos los otros al arrancar el sistema. Podríamos tener entonces algo como esto:

[root@Centos foo]# pstree
init-+-bbpager
     |-bdflush
     |-login---bash---startx---xinit-+-X
     |                               `-blackbox---xscreensaver

La lista será más larga, pero aquí podemos ver los conceptos de los que hablábamos: pstree (árbol de procesos) muestra todos los procesos principales en árbol. Cuando un proceso se ramifica se muestra un símbolo +, y todos los procesos forkeados aparecen a igual altura. Además, un proceso hijo se muestra como una rama de su padre. En el ejemplo, bash es hijo de login, y startx es hijo de bash.

Ya que hemos hablado de padres e hijos, hablemos de herencia. Como verá en el tutorial sobre usuarios y permisos, cada archivo (y también cada programa) tienen permisos de usuario. Ahora bien, cuando un proceso “nace” hereda algunos de los privilegios o permisos de su padre, a menos que (aquí empieza la diferencia con la vida real) tenga otros propios. Un servidor web o un programa no corren con privilegios de root sólo porque init sí lo hace. Esto depende en parte de que antes de usarlos hay que conectarse usando login, y en parte de que algunos procesos tienen definida su propia cuenta de usuario.

Pero basta de teoría, y sigamos viendo cómo administrar procesos. Ya vimos dos o tres programas importantes: top, ps y kill. Ahora seguiremos con nice y renice.

Salu2,

Lester Espinosa Martínez

Colas de comandos

Hola a todos nuevamente, hoy les dejo un importante proceso, el de las colas de comandos en la shell.

Cuando está trabajando, puede alguna vez querer ejecutar un montón de comandos y dedicar su atención de nuevo a otra cosa (digamos centericq, por ejemplo). El tipo de orden que de depende de una cosa: la relación entre los comandos. Si el resultado de un comando no influye en el comando siguiente, basta usar el símbolo ; para separar comandos en una línea. Si en cambio usted está haciendo una tarea (como compilar el núcleo) que necesita que cada uno de los comandos tenga éxito antes de empezar el siguiente, usará el símbolo &&.

Por ejemplo:

[lester@Centos lester]$ cd docs/foo/ ; ls ~
borrados.log  docs/  tmp/  xcdroast/
[lester@Centos foo]$

Nos lleva al directorio ~/docs/foo (como se ve por el prompt) y además muestra los archivos del directorio personal. Pero note esto:

[lester@Centos foo]$ cd docs/foo/bar/ ; ls ~
-bash: cd: docs/foo/bar/: No such file or directory
borrados.log  docs/  tmp/  xcdroast/
[lester@Centos foo]$

Aquí, aunque la primera orden tiene un error (no existe el directorio bar dentro de foo) la segunda orden sigue cumpliéndose.

Una última nota antes de seguir: cuando vea scripting en otros lenguajes, como perl, python o PHP, notará que el punto y coma se usa para separar comandos de la misma manera.

Ahora veamos el segundo modo con un ejemplo: compilar un programa es una tarea que implica una serie de pasos, y cada uno de ellos debe completarse sin errores para pasar al siguiente, y por eso usamos &&: sólo se pasa a la segunda etapa si la primera terminó correctamente:

[root@Centos foo]# ./configure && make && make install

compilará correctamente el programa, o se detendrá al primer error. Note que estamos logueados como el usuario root para poder ejecutar make install normalmente.

Espero que les haya resultado de gran utilidad…

Salu2,

Lester Espinosa Martínez

BG y FG: “minimizar” y “restaurar” en consola

Hola a todos nuevamente, aquí les traigo un tema de mucho interés, dado que la mayoría de los que utilizamos sistemas operativos GNU/Unix son con propósitos de servidores y para el ahorro de memoria y demás lo hacemos en consolas, no en pantalla gráfica.

Dado que Linux es un kernel con capacidades de multitarea, el shell incorpora comandos para hacer que los programas pasen al frente o al fondo, es decir, son el equivalente en el shell de las acciones “minimizar” y “restaurar”. bg envía un trabajo o proceso (un programa que está corriendo) atrás, y fg lo vuelve a traer. Si ha lanzado un comando en una consola puede pulsar Control + Z para pausar el proceso y bg para enviarlo al fondo. Ejemplo:

[lester@Centos docs]$ gnomeicu
(presionamos Control + Z)
[1]+  Stopped                 gnomeicu
[lester@Centos docs]$ bg
[1]+ gnomeicu &
[lester@Centos docs]$ fg
gnomeicu

Luego de ejecutar gnomeicu, pulsamos Control + Z. El trabajo se detuvo, y lo hicimos rearrancar en segundo plano con la orden bg. Note que el mismo resultado puede obtenerse ejecutando directamente gnomeicu &. El símbolo & aplicado al final de un comando hace que se ejecute en segundo plano. Por supuesto, eso no se limita a un solo programa: puede iniciar en segundo plano todos los programas que necesite. Ejecute el comando jobs para verlos a todos:

[lester@Centos lester]$ jobs
[1]-  Running                 gnomeicu &
[2]+  Running                 aterm &

Tenemos dos procesos corriendo ahora en segundo plano. Note el número a la izquierda: fg permite traer al primer plano selectivamente un proceso (por defecto el último) usando ese número. Por ejemplo:

[lester@Centos lester]$ fg
aterm
[lester@Centos lester]$ fg 1
gnomeicu

Espero les haya resultado de gran utilidad…

Salu2,

Lester Espinosa Martínez

Cómo monitorear procesos en las consolas desde la 8 a la 12…

Hola a todos nuevamente, aquí les dejo un importante proceso de un administrador de redes, el de utilizar las consolas desde la 8 a la 12 para monitorear lo que está sucediendo en nuestro sistema…

El truco básicamente está en editar el fichero:

Fichero –> /etc/rc.d/rd.local

###################################################################
#!/bin/sh
#
# This script will be executed *after* all the other init scripts.
# You can put your own initialization stuff in here if you don’t
# want to do the full Sys V style init stuff.

##########################################
# Ejecutando fetchmail como demonio al comienzo
#
/etc/fetchmail/run-fetchmail
##########################################
# Observando las conexiones TCP en la consola tty8
#
/usr/bin/watch -n 5 /bin/netstat -tn > /dev/tty8 &
#
#########################################
# Observando el fichero squid.log en la consola tty9
#
/usr/bin/tail -f /var/log/squid/access.log > /dev/tty9 &
#
###################################
# Observando el fichero fetchmail.log en la consola tty10
#
/usr/bin/tail -f /var/log/fetchmail/fetchmail.log > /dev/tty10 &
#
###########################################
# Observando el log del correo en la consola tty11
#
/usr/bin/tail -f /var/log/maillog > /dev/tty11 &
#
########################################
# Observando el log de mensajes en la consola tty12
#
/usr/bin/tail -f /var/log/messages > /dev/tty12 &
#
###################################################################

Espero que les sea de gran utilidad…

Salu2,

Lester Espinosa Martínez