Guía para Maestría Avanzada de Comandos Linux

Guía para Maestría Avanzada de Comandos Linux
Por Arup Nanda
Publicado en agosto de 2006
En el excelente artículo de Sheryl Calish, denominado “Guía para Maestría en Comandos de Archivos Linux",
usted conoció algunos comandos Linux de rutina, que son especialmente valiosos para principiantes Linux.
Pero ahora que conoce los puntos básicos, prosigamos con algunos comandos más sofisticados que
encontrará extremadamente útiles.
En esta serie de cuatro partes, conocerá algunos trucos no tan conocidos sobre varios comandos de rutina,
así como las variaciones en uso que los hacen más útiles. A medida que la serie avanza, conocerá comandos
cada vez más difíciles de dominar.
Tenga en cuenta que estos comandos pueden diferir de acuerdo con la versión específica de Linux que utilice
o qué kernel específica se compila, pero en ese caso, probablemente solo sea una diferencia mínima.
Cambios Sencillos a Propietarios, Grupos y
Permisos
En el artículo de Sheryl, usted aprendió cómo utilizar los comandos chown y chgrp para cambiar la propiedad
y el grupo de los archivos. Supongamos que tiene varios archivos como este:
# ls -l
total 8
-rw-r--r--rwxr-xr-x
-rwxr-xr-x
-rwxr-xr-x
-rwxr-xr-x
-rwxr-xr-x
1
1
1
1
1
1
ananda
oracle
oracle
oracle
oracle
oracle
users
dba
dba
dba
dba
dba
70
132
132
132
132
132
Aug
Aug
Aug
Aug
Aug
Aug
4
4
4
4
4
4
04:02
04:02
04:02
04:02
04:02
04:02
file1
file2
file3
file4
file5
file6
y necesita cambiar los permisos de todos los archivos para asociar aquellos del archivo 1. Seguramente
podría utilizar chmod 644 * para realizar ese cambio— ¿pero qué sucede si está escribiendo un script para
hacerlo y no sabe cuáles son los permisos de antemano? O, tal vez esté hacienda varios cambios de permiso
basados en muchos archivos diferentes y cree que no es factible examinar los permisos de cada uno y
modificarlos en consecuencia.
Un mejor enfoque es hacer que los permisos sean similares a aquellos de otro archivo. Este comando hace
que los permisos del archivo 2 sean los mismos que el archivo 1:
chmod --reference file1 file2
Ahora, si verifica:
# ls -l file[12]
total 8
-rw-r--r-1 ananda
-rw-r--r-1 oracle
users
dba
70 Aug
132 Aug
4 04:02 file1
4 04:02 file2
Los permisos del archivo 2 fueron cambiados exactamente como el archivo 1. No necesitó obtener primero los
permisos del archivo 1.
Usted también puede utilizar el mismo truco para la membresía de grupos en los archivos. Para que el grupo
del archivo 2 sea el mismo que el archivo 1, usted manifestaría:
# chgrp --reference file1 file2
# ls -l file[12]
-rw-r--r-1 ananda
users
-rw-r--r-1 oracle
users
70 Aug
132 Aug
4 04:02 file1
4 04:02 file2
Desde luego, lo que funciona para el cambio de grupos funcionará para el propietario también. A continuación,
mostramos cómo puede utilizar el mismo truco para un cambio de propiedad. Si los permisos son así:
# ls -l file[12]
-rw-r--r-1 ananda
-rw-r--r-1 oracle
users
dba
70 Aug
132 Aug
4 04:02 file1
4 04:02 file2
70 Aug
132 Aug
4 04:02 file1
4 04:02 file2
Usted puede cambiar la propiedad así:
# chown --reference file1 file2
# ls -l file[12]
-rw-r--r-1 ananda
users
-rw-r--r-1 ananda
users
Fíjese que el grupo, y el propietario, han cambiado.
Consejo para Usuarios Oracle
Este es un truco que puede utilizar para cambiar la propiedad y los permisos de los ejecutables de Oracle en
un directorio basado en un ejecutable de referencia. Esto es especialmente útil en migraciones donde puede
(y probablemente deba) instalar un usuario diferente y luego trasladarlo a su propietario de software Oracle
usual.
Más sobre Archivos
El comando ls, con su gran cantidad de argumentos, brinda información muy útil sobre los archivos. Un
comando diferente y menos conocido – stat – ofrece información incluso más útil. .
Aquí le mostramos cómo puede utilizarlo en el ejecutable “oracle”, que puede encontrarse en
$ORACLE_HOME/bin.
# cd $ORACLE_HOME/bin
# stat oracle
File: `oracle'
Size: 93300148
Blocks: 182424
IO Block: 4096
Device: 343h/835d
Inode: 12009652
Links: 1
Access: (6751/-rwsr-s--x) Uid: ( 500/ oracle)
Gid: (
Access: 2006-08-04 04:30:52.000000000 -0400
Modify: 2005-11-02 11:49:47.000000000 -0500
Change: 2005-11-02 11:55:24.000000000 -0500
Regular File
500/
dba)
Fíjese la información que obtuvo con este comando: Además del tamaño de archivo usual (que puede obtener
de ls -l), usted obtuvo la cantidad de bloques que ocupa este archivo. El tamaño de bloque Linux típico es
de 512 bytes, entonces un archivo de 93.300.148 bytes ocuparía (93300148/512=) 182226.85 bloques. Como
los bloques se utilizan en su totalidad, este archivo utiliza un número entero de bloques. En lugar de hacer
conjeturas, usted puede saber cuáles son los bloques exactos.
Del output de arriba, usted también puede conocer el GID y UID de la propiedad del archivo y la
representación octal de los permisos (6751). Si desea readmitir los mismos permisos que tiene ahora, puede
utilizar chmod 6751 oracle en lugar de detallar explícitamente los permisos.
La parte más útil del output de arriba es la información de la fecha de registro del acceso al archivo. Muestra
que se accedió al archivo el 04-08-2006 a las 04:30:52 (como se muestra al lado de “Acceso:”), o el 4 de
agosto de 2006 a las 4:30:52 AM. Este es el momento en el cual se empezó a utilizar la base de datos. El
archivo fue modificado el 02-11-2005 a las 11:49:47 (como se muestra al lado de Modificar:). Finalmente, la
fecha de registro al lado de “Cambiar:” muestra cuándo fue cambiado el estado del archivo.
-f, un modificador del comando stat, muestra la información del sistema de archivo en lugar del archivo:
# stat -f oracle
File: "oracle"
ID: 0
Namelen: 255
Type: ext2/ext3
Blocks: Total: 24033242
Free: 15419301
Available: 14198462
4096
Inodes: Total: 12222464
Free: 12093976
Size:
Otra opción, -t, brinda exactamente la misma información pero en una sola línea:
# stat -t oracle
oracle 93300148 182424 8de9 500 500 343 12009652 1 0 0 1154682061
1130950187 1130950524 4096
Esto es muy útil en shell scripts donde un simple comando de corte puede utilizarse para extraer los valores
para el posterior procesamiento.
Consejo para Usuarios Oracle
Cuando usted se vuelve a conectar con Oracle (a menudo se realiza durante la instalación de parches), los
ejecutables existentes pasan a un nombre diferente antes de crear el nuevo. Por ejemplo, puede reconectar
todos los servicios por
relink utilities
Recopila, entre otras cosas, el ejecutable sqlplus. Mueve el ejecutable existente sqlplus a sqlplus. O Si la
recopilación falla por algún motivo, el proceso de reconexión vuelve a nombrar sqlplusO con sqlplus, y los
cambios quedan anulados. De manera similar, si descubre un problema de funcionalidad después de aplicar
un parche, puede rápidamente anular el parche al renombrar el archivo por su propia cuenta.
A continuación, mostramos cómo puede utilizar stat en estos archivos:
# stat sqlplus*
File: 'sqlplus'
Size: 9865
Blocks: 26
IO Block: 4096
Regular File
Device:
Access:
Access:
Modify:
Change:
343h/835d
Inode: 9126079
Links: 1
(0751/-rwxr-x--x) Uid: ( 500/ oracle)
Gid: (
2006-08-04 05:15:18.000000000 -0400
2006-08-04 05:15:18.000000000 -0400
2006-08-04 05:15:18.000000000 -0400
File:
Size:
Device:
Access:
Access:
Modify:
Change:
'sqlplusO'
8851
Blocks: 24
IO Block: 4096
343h/835d
Inode: 9125991
Links: 1
(0751/-rwxr-x--x) Uid: ( 500/ oracle)
Gid: (
2006-08-04 05:13:57.000000000 -0400
2005-11-02 11:50:46.000000000 -0500
2005-11-02 11:55:24.000000000 -0500
500/
dba)
Regular File
500/
dba)
Muestra que sqlplusO fue modificado el 11 de noviembre d e2005, cuando sqlplus fue modificado el 4 de
agosto de 2006, que también corresponde al tiempo de cambio de estado de sqlplusO. Indica que la versión
original de sqlplus estuvo vigente desde el 11 de noviembre de 2005 hasta el 4 de agosto de 2006. Si quiere
diagnosticar algunos problemas de funcionalidad, este es un buen lugar para empezar. Además de los
cambios de archivo, como usted conoce el horario de cambio de los permisos, usted puede correlacionarlo
con cualquier problema de funcionalidad percibido.
Otro output importante es el tamaño del archivo, que es diferente—9865 bytes para sqlplus y 8851 para
sqlplusO—e indica que las versiones no son meras compilaciones; en realidad cambiaron con bibliotecas
adicionales (tal vez). Esto también indica la causa potencial de algunos problemas.
Tipos de Archivo
Cuando ve un archivo, ¿cómo sabe qué tipo de archivo es? El comando file le da esa información. Por
ejemplo:
# file alert_DBA102.log
alert_DBA102.log: ASCII text
El archivo alert_DBA102.log es un archivo de texto ASCII. Veamos algunos ejemplos más:
# file initTESTAUX.ora.Z
initTESTAUX.ora.Z: compress'd data 16 bits
Esto demuestra que el archivo es un archivo comprimido, ¿pero cómo sabe qué tipo de archivo fue
comprimido? Una opción es descomprimirlo y ejecutar el archivo; pero eso haría que sea virtualmente
imposible. Una mejor opción es utilizar el parámetro -z:
# file -z initTESTAUX.ora.Z
initTESTAUX.ora.Z: ASCII text (compress'd data 16 bits)
Otra peculiaridad es la presencia de enlaces simbólicos:
# file spfile+ASM.ora.ORIGINAL
spfile+ASM.ora.ORIGINAL: symbolic link to
/u02/app/oracle/admin/DBA102/pfile/spfile+ASM.ora.ORIGINAL
Esto es útil; ¿pero qué tipo de archivo es al que se apunta? En lugar de ejecutar el archivo otra vez, puede
utilizar la opción -l:
# file -L spfile+ASM.ora.ORIGINAL
spfile+ASM.ora.ORIGINAL: data
Esto demuestra claramente que el archivo es un archivo de datos. Tenga en cuenta que spfile es binario, a
diferencia de init.ora; por lo tanto el archivo se muestra como archivo de datos.
Consejo para Usuarios Oracle
Supongamos que está buscando un archivo de localización en el directorio de destino de descargas del
usuario pero no está seguro de que el archivo esté ubicado allí o en otro directorio, y meramente está allí
como enlace simbólico, o si alguien ha comprimido el archivo (o incluso lo ha renombrado). Hay algo que sí
sabe: es definitivamente un archivo ascii. ¿Qué puede hacer?
file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr
Este comando verifica los archivos ASCII, incluso si están comprimidos, y los enumera en orden cronológico.
Comparar Archivos
¿Cómo descubre si dos archivos—archivo1 y archivo2—son idénticos? Hay varias formas, y cada enfoque
tiene su propio atractivo.
diff. El comando más simple es diff, que muestra la diferencia entre dos archivos. Vea los contenidos de
dos archivos
# cat file1
In file1 only
In file1 and file2
# cat file2
In file1 and file2
In file2 only
Si utiliza el comando diff, podrá ver la diferencia entre los archivos, como se muestra abajo:
# diff file1 file2
1d0
< In file1 only
2a2
> In file2 only
#
En el output, un "<" en la primera columna indica que la línea existe en el archivo mencionado primero, —es
decir, archivo1. Un ">" en ese lugar indica que la línea existe en el segundo archivo (archivo2). Los caracteres
1d0 de la primera línea del output muestra lo que debe hacerse en sed para operar en el archivo 1 para
hacerlo idéntico al archivo 2.
Otra opción, -y, muestra el mismo output, pero uno al lado del otro:
# diff -y file1 file2 -W 120
In file1 only
In file1 and file2
<
>
In file1 and file2
In file2 only
La opción -W es opcional; simplemente ordena al comando utilizar una pantalla que permita 120 caracteres,
útil para archivos con líneas largas.
Si solo desea saber si los archivos son diferentes, no necesariamente en qué difieren, puede utilizar la opción
-q.
# diff -q file3 file4
# diff -q file3 file2
Files file3 and file2 differ
Los archivos 3 y 4 son los mismos, con lo cual no hay output; caso contrario, se informa si los archivos
difieran.
Si está escribiendo un shell script, puede resultar útil generar el output de tal manera que pueda analizarse. La
opción -u hace eso:
# diff -u file1 file2
--- file1
2006-08-04 08:29:37.000000000 -0400
+++ file2
2006-08-04 08:29:42.000000000 -0400
@@ -1,2 +1,2 @@
-In file1 only
In file1 and file2
+In file2 only
El output muestra contenidos de ambos archivos pero suprime los duplicados, los signos + y – de la primera
columna indican las líneas de los archivos. Ningún carácter en la primera columna indica su presencia en
ambos archivos.
El comando tiene en cuenta el espacio en blanco. Si quiere ignorar el espacio en blanco, use la opción -b.
Use la opción -B para ignorar las líneas en blanco. Finalmente, use -i para ignorar el caso.
El comando diff también puede aplicarse a los directorios. El comando
diff dir1 dir2
muestra los archivos presentes en cualquiera de los dos directorios; ya sea que los archivos estén presentes
en uno de los directorios o en ambos. Si se encuentra un subdirectorio con el mismo nombre, no se detiene a
ver si algún archivo individual difiere. Un ejemplo:
# diff DBA102 PROPRD
Common subdirectories: DBA102/adump and PROPRD/adump
Only in DBA102: afiedt.buf
Only in PROPRD: archive
Only in PROPRD: BACKUP
Only in PROPRD: BACKUP1
Only in PROPRD: BACKUP2
Only in PROPRD: BACKUP3
Only in PROPRD: BACKUP4
Only in PROPRD: BACKUP5
Only in PROPRD: BACKUP6
Only in PROPRD: BACKUP7
Only in PROPRD: BACKUP8
Only in PROPRD: BACKUP9
Common subdirectories: DBA102/bdump and PROPRD/bdump
Common subdirectories: DBA102/cdump and PROPRD/cdump
Only in PROPRD: CreateDBCatalog.log
Only in PROPRD: CreateDBCatalog.sql
Only in PROPRD: CreateDBFiles.log
Only in PROPRD: CreateDBFiles.sql
Only in PROPRD: CreateDB.log
Only in PROPRD: CreateDB.sql
Only in DBA102: dpdump
Only in PROPRD: emRepository.sql
Only in PROPRD: init.ora
Only in PROPRD: JServer.sql
Only in PROPRD: log
Only in DBA102: oradata
Only in DBA102: pfile
Only in PROPRD: postDBCreation.sql
Only in PROPRD: RMANTEST.sh
Only in PROPRD: RMANTEST.sql
Common subdirectories: DBA102/scripts and PROPRD/scripts
Only in PROPRD: sqlPlusHelp.log
Common subdirectories: DBA102/udump and PROPRD/udump
Vea que los subdirectorios comunes simplemente se muestran como tal pero no se realiza ninguna
comparación. Si desea hacer más desgloses y comparar los archivos de esos subdirectorios, debería utilizar
el siguiente comando:
diff -r dir1 dir2
Este comando ingresa repetitivamente en cada subdirectorio para comparar los archivos e informa la
diferencia entre los archivos con el mismo nombre.
Consejo para Usuarios Oracle
Un uso común de diff es diferenciar entre distintos archivos init.ora. Como ejemplo modelo, siempre copio el
archivo con un nuevo nombre—por ej., initDBA102.ora con initDBA102.080306.ora (para indicar 3 de agosto
de 2006) —antes de realizar un cambio. Un simple diff entre todas las versiones del archivo muestra
rápidamente qué cambió y cuándo.
Este es un comando bastante poderoso para administrar su página de inicio Oracle. Como ejemplo modelo,
nunca actualizo una Página de Inicio de Oracle cuando aplico parches. Por ejemplo, supongamos que las
versiones Oracle actuales sean 10.2.0.1. ORACLE_HOME podría ser /u01/app/oracle/product/10.2/db1.
Cuando llega el momento de realizar un parche hacia 10.2.0.2, no realizo el parche de esta Página de Inicio
Oracle. En cambio, inicio una instalación nueva en /u01/app/oracle/product/10.2/db2 y luego realizo un parche
de esa página de inicio. Una vez listo, uso lo siguiente:
# sqlplus / as sysdba
SQL> shutdown immediate
SQL> exit
# export ORACLE_HOME=/u01/app/oracle/product/10.2/db2
# export PATH=$ORACLE_HOME/bin:$PATH
# sqlplus / as sysdba
SQL> @$ORACLE_HOME/rdbms/admin/catalog
...
y así sucesivamente.
El propósito de este enfoque es que la Página de Inicio Oracle original no se interrumpa y que pueda
fácilmente volver atrás en caso de haber problemas. Esto también implica que la base de datos deja de
funcionar y vuelve a hacerlo, con bastante rapidez. Si hubiese instalado un parche directamente en la Página
de Inicio Oracle, hubiese tenido que interrumpir la base de datos durante mucho tiempo—mientras dure la
aplicación del parche. Asimismo, si la aplicación del parche hubiese fallado por algún motivo, no hubiese
obtenido una Página de Inicio Oracle “limpia”.
Ahora que tengo varias Páginas de Inicio Oracle, ¿cómo puedo ver qué cambió? Es realmente simple; puedo
utilizar:
diff -r /u01/app/oracle/product/10.2/db1 /u01/app/oracle/product/10.2/db2
|
grep -v Common
Esto me muestra las diferencias entre ambas Páginas de Inicio Oracle y las diferencias entre los archivos con
el mismo nombre. Algunos archivos importantes como tnsnames.ora, listener.ora y sqlnet.ora no deberían
mostrar grandes diferencias, pero si lo hacen, debo entender por qué.
cmp. El comando cmp es similar a diff:
# cmp file1 file2
file1 file2 differ: byte 10, line 1
El output vuelve a aparecer como la primera señal de diferencia. Usted puede utilizar esto para identificar en
qué pueden diferir los archivos. diff, cmp tiene muchas opciones, la más importante es la opción -s, lo cual
sencillamente genera un código



0, si los archivos son idénticos
1, si difieren
Algún otro número que no sea cero, si la comparación no pudo realizarse
Un ejemplo:
# cmp -s file3 file4
# echo $?
0
La variable especial $? indica el código del último comando ejecutado. En este caso, 0, lo cual implica que los
archivos 1 y 2 son idénticos.
# cmp -s file1 file2
# echo $?
1
implica que los archivos 1 y 2 no son iguales.
Esta propiedad de cmp puede resultar muy útil en shell scripting donde simplemente quiera verificar si dos
archivos difieren de alguna manera, pero no necesariamente verificar cuál es la diferencia. Otro uso
importante de este comando es comparar los archivos binarios, donde diff puede no ser confiable.
Consejo para Usuarios Oracle
Recuerde de un consejo anterior, cuando vuelve a conectar los ejecutables Oracle, la versión más antigua se
guarda antes de sobrescribirla. Por lo tanto, cuando se vuelve a conectar, el ejecutable sqlplus es renombrado
como “sqlplusO”, y el recientemente compilado sqlplus es colocado en $ORACLE_HOME/bin. ¿Entonces
cómo se asegura de que el sqlplus que se creó recientemente es diferente? Simplemente utilice:
# cmp sqlplus sqlplusO
sqlplus sqlplusO differ: byte 657, line 7
Si verifica el tamaño:
# ls -l sqlplus*
-rwxr-x--x
1 oracle
-rwxr-x--x
1 oracle
dba
dba
8851 Aug
8851 Nov
4 05:15 sqlplus
2 2005 sqlplusO
A pesar de que el tamaño es el mismo en ambos casos, cmp demostró que los dos programas son diferentes.
comm. El comando comm es similar a los otros pero el output se genera en tres columnas, separadas por
etiquetas. Ejemplo:
# comm file1 file2
In file1 and file2
In file1 only
In file1 and file2
In file2 only
Resumen de Comandos de este
Documento
Commando
Uso
chmod
Para cambiar
permisos de un
archivo, usando el
parámetro de
referencia - -
chown
Para cambiar el
Este comando es útil para ver los contenidos de un archivo y no
del otro, no solo una diferencia—una clase de herramienta MINUS
en el lenguaje SQL. La opción -1 suprime los contenidos del
primer archivo:
propietario de un
archivo, usando el
parámetro de
referencia - -
# comm -1 file1 file2
In file1 and file2
In file2 only
chgrp
Para cambiar el
grupo de un archivo,
usando el parámetro
de referencia - -
md5sum. Este comando genera un valor arbitrario MD5 de 32
bits de los archivos:
stat
Para conocer los
atributos extendidos
de un archivo, como
fecha de último
acceso
file
Para conocer el tipo
de archivo, como
ASCII, datos, etc.
diff
Para ver la diferencia
entre dos archivos
cmp
Para comparar dos
archivos
comm
Para ver qué tienen
en común dos
archivos, con el
output en tres
columnas
md5sum
Para calcular el valor
arbitrario MD5 de los
archivos, usado para
determinar si un
archivo ha cambiado
# md5sum file1
ef929460b3731851259137194fe5ac47
file1
Dos archivos con la misma suma de control (checksum) pueden
considerarse idénticos. No obstante, la utilidad de este comando
va más allá de simplemente comparar los archivos. También
puede ofrecer un mecanismo para garantizar la integridad de los
archivos.
Supongamos que tiene dos archivos importantes—archivo1 y 2—
que necesita proteger. Puede utilizar el control de opción -check para confirmar que los archivos no han cambiado.
Primero, cree un archivo de suma de control para ambos archivos
importantes y manténgalos protegidos:
# md5sum file1 file2 > f1f2
Luego, cuando quiere verificar que los archivos siguen intactos:
# md5sum --check f1f2
file1: OK
file2: OK
Esto muestra claramente que los archivos no han sido modificados. Ahora cambia un archivo y verifique el
MD5:
# cp file2 file1
# md5sum --check f1f2
file1: FAILED
file2: OK
md5sum: WARNING: 1 of 2 computed checksums
did NOT match
El output claramente muestra que el archivo 1 ha sido modificado.
Consejo para Usuarios Oracle
md5sum es un comando extremadamente poderoso para implementaciones de seguridad. Algunos archivos
de configuración que administra, como listener.ora, tnsnames.ora e init.ora, son demasiado críticos para una
infraestructura Oracle exitosa, y cualquier modificación puede dar como resultado momentos de inactividad.
Esto en general forma parte de su proceso de control de cambios. En lugar de confiar en la palabra de alguien
respecto de que estos archivos no han cambiado, asegúrese utilizando la suma de control MD5. Cree un
archivo de suma de control y, cuando realice un cambio planificado, vuelva a crear este archivo. Como parte
del cumplimiento, verifique este archivo utilizando el comando md5sum . Si alguien actualizara
involuntariamente alguno de estos archivos clave, inmediatamente se daría cuenta del cambio.
En la misma línea, también puede crear sumas de control MD5 para todos los ejecutables de
$ORACLE_HOME/bin y compararlas de vez en cuando para realizar modificaciones no autorizadas.
Conclusión
Hasta ahora, ha aprendido solo algunos de los comandos Linux que encontrará útiles para realizar una tarea
con eficiencia. En el próximo documento, describiré algunos comandos más sofisticados pero útiles, como
strace, whereis, renice, skill, y mucho más.
Guía para Maestría Avanzada de Comandos Linux Parte 2
Por Arup Nanda
Publicado en febrero de 2008
En la Parte 1 de la serie, usted aprendió algunos comandos útiles no tan conocidos y algunos de los comandos
comúnmente utilizados pero con parámetros no tan conocidos para hacer su trabajo de manera más eficiente.
Para continuar con la serie, ahora aprenderá algunos comandos Linux más avanzados útiles para los usuarios
Oracle, ya sean desarrolladores o DBAs.
Alias y unalias
Supongamos que quiere verificar el grupo de variables del entorno ORACLE_SID de su shell. Deberá tipear:
echo $ORACLE_HOME
Como DBA o desarrollador, utiliza frecuentemente este comando y pronto se cansa de tipear los 16
caracteres. ¿Hay una manera más simple?
Sí: el comando alias. Con este enfoque, puede crear un breve alias, como "os", para representar todo el
comando:
alias os='echo $ORACLE_HOME'
Ahora cuando quiera verificar ORACLE_SID, simplemente escriba "os" (sin comillas) y Linux ejecuta el
comando con el alias.
No obstante, si se desconecta y se vuelve a conectar, el alias es eliminado y debe ingresar el comando alias
nuevamente. Para eliminar este paso, todo lo que debe hacer es colocar el comando en su archivo de perfil
shell. Para bash, el archivo es .bash_profile (note el punto antes del nombre de archivo, es parte del nombre
de archivo) en su directorio de inicio. Para los shells bourne y korn, es .profile, y para c-shell, .chsrc.
Usted puede crear un alias para cualquier nombre. Por ejemplo, yo siempre creo un alias para el comando rm
como rm -i, que hace que el comando rm sea interactivo.
alias rm=’rm -i’
Cuando emito un comando rm, Linux solicita mi confirmación, y a menos que agregue "y", no elimina el
archivo—así quedo protegido ante la posibilidad de eliminar accidentalmente un archivo importante. Utilizo lo
mismo para mv (para cambiar el archivo a otro nombre), lo cual evita la sobrescritura accidental de archivos
existentes, y cp (para copiar el archivo).
A continuación, presentamos una lista de algunos alias muy útiles que quiero definir:
alias
alias
alias
alias
alias
alias
alias
alias
bdump='cd $ORACLE_BASE/admin/$ORACLE_SID/bdump'
l='ls -d .* --color=tty'
ll='ls -l --color=tty'
mv='mv -i'
oh='cd $ORACLE_HOME'
os='echo $ORACLE_SID'
rm='rm -i'
tns='cd $ORACLE_HOME/network/admin'
Para ver qué alias han sido definidos en su shell, use alias sin ningún parámetro.
Sin embargo, hay un pequeño problema. He definido un alias, rm, que ejecuta rm -i. Este comando solicitará
mi confirmación cada vez que intente eliminar un archivo. ¿Pero qué sucede si quiero eliminar muchos
archivos y estoy seguro de que pueden eliminarse sin mi confirmación?
La solución es simple: Para suprimir el alias y utilizar solo el comando, necesitaré ingresar dos comillas
simples:
$ ''rm *
Fíjese que se trata de dos comillas simples (') antes del comando rm, no dos comillas dobles. Esto suprimirá
el alias rm. Otro enfoque es utilizar una barra inversa (\):
$ \rm *
Para eliminar un alias previamente definido, simplemente utilice el comando unalias:
$ unalias rm
ls
El comando ls es frecuentemente utilizado pero pocas veces es utilizado en su totalidad. Sin ninguna opción,
ls despliega meramente todos los archivos y directorios en formato tabular.
$ ls
admin
apex
assistants
has
hs
install
mesg
mgw
network
precomp
racg
rdbms
... output snipped ...
Para mostrarlos en una lista, use la opción -1 (el número 1, no la letra "l").
$ ls -1
admin
apex
assistants
... output snipped ...
Esta opción es útil en shell scripts donde los nombres de archivo necesitan incorporarse en otro programa o
comando para la manipulación.
Seguramente, usted utilizó -l (la letra "l", no el número "1") que despliega todos los atributos de los archivos y
directorios. Veámoslo una vez más:
$ ls -l
total 272
drwxr-xr-x
drwxr-x--drwxr-x---
3 oracle
7 oracle
7 oracle
oinstall
oinstall
oinstall
4096 Sep
4096 Sep
4096 Sep
3 03:27 admin
3 02:32 apex
3 02:29 assistants
La primera columna muestra el tipo de archivo y los permisos sobre él: "d" significa directorio, "-" significa
archivo regular, "c" significa un dispositivo de caracteres, "b" significa un dispositivo de bloques, "p" significa
named pipe, y "l" (letra minúscula L, no I) significa enlace simbólico.
Una opción muy útil es --color, que muestra los archivos en muchos colores diferentes de acuerdo con el tipo
de archivo. Aquí hay un ejemplo:
Fíjese que los archivos 1 y 2 son archivos comunes. link1 es un enlace simbólico, que se muestra en rojo; dir1
es un directorio y se muestra en amarillo; y pipe1 es un named pipe, y se muestra en diferentes colores para
una identificación más fácil.
En algunos distros, el comando ls viene preinstalado con un alias (descripto en la sección anterior) como ls -color; de manera que usted pueda ver los archivos en color cuando tipea "ls". Este enfoque puede no ser
aconsejable, especialmente si tiene un output como ese arriba. Puede cambiar los colores, pero una forma
más rápida puede ser simplemente suspender el alias:
$ alias ls="''ls"
Otra opción útil es la opción -F, que añade un símbolo después de cada archivo para mostrar el tipo de
archivo - una "/" después de los directorios, "@" después de enlaces simbólicos, y "|" después de named
pipes.
$ ls -F
dir1/ file1
file2
link1@
pipe1|
Si tiene un subdirectorio en un directorio y quiere hacer solo una lista de ese directorio, ls -l le mostrará los
contenidos del subdirectorio también. Por ejemplo, supongamos que la estructura de directorio es la siguiente:
/dir1
+-->/subdir1
+--> subfile1
+--> subfile2
El directorio dir1 tiene un subdirectorio subdir1 y dos archivos: subfile1 y subfile2. Si solo desea ver los
atributos del directorio dir1, emite:
$ ls -l dir1
total 4
drwxr-xr-x
-rw-r--r--rw-r--r--
2 oracle
1 oracle
1 oracle
oinstall
oinstall
oinstall
4096 Oct 14 16:52 subdir1
0 Oct 14 16:48 subfile1
0 Oct 14 16:48 subfile2
Fíjese que el directorio dir1 no está en la lista del output. En cambio, se muestran los contenidos del directorio.
Este es un comportamiento esperado cuando se procesan directorios. Para mostrar únicamente el directorio
dir1, deberá utilizar el comando -d.
$ ls -dl dir1
drwxr-xr-x
3 oracle
oinstall
4096 Oct 14 16:52 dir1
Vea el output del siguiente output ls -l:
-rwxr-x--x
-rwxr-x--x
-rwsr-s--x
-rwx------
1
1
1
1
oracle
oracle
oracle
oracle
oinstall
oinstall
oinstall
oinstall
10457761
10457761
93300507
93300507
Apr 6 2006
Sep 23 23:48
Apr 6 2006
Sep 23 23:49
rmanO
rman
oracleO
oracle
Notará que los tamaños de los archivos se muestran en bytes. Esto puede ser fácil en archivos pequeños,
pero cuando el tamaño de los archivos es grande, puede no ser tan fácil leer un número largo. La opción "-h"
es práctica aquí, para mostrar el tamaño de manera legible para personas.
$ ls -lh
-rwxr-x--x
-rwxr-x--x
-rwsr-s--x
-rwx------
1
1
1
1
oracle
oracle
oracle
oracle
oinstall
oinstall
oinstall
oinstall
10M
10M
89M
89M
Apr 6 2006
Sep 23 23:48
Apr 6 2006
Sep 23 23:49
rmanO
rman
oracleO
oracle
Fíjese cómo se muestra el tamaño en M (para megabytes), K (para kilobytes), etc.
$ ls -lr
El parámetro -r muestra el output en orden inverso. En este comando, los archivos se mostrarán en orden
alfabético inverso.
$ ls -lR
El operador -R hace que el comando ls se ejecute repetitivamente—es decir, explorar los subdirectorios y
mostrar esos archivos también.
¿Qué sucede si quiere mostrar los archivos del más grande al más chico? Esto puede realizarse con el
parámetro -S.
$ ls -lS
total 308
-rw-r-----rwxr-xr-x
drwxr-xr-x
drwxr-x---
1
1
2
3
oracle
oracle
oracle
oracle
oinstall
oinstall
oinstall
oinstall
52903
9530
8192
8192
Oct 11 18:31 sqlnet.log
Apr 6 2006 root.sh
Oct 11 18:14 bin
Sep 23 23:49 lib
xargs
La mayoría de los comandos Linux tienen el fin de obtener un output: una lista de archivos, una lista de
sucesiones, etc. ¿Pero qué sucede si quiere utilizar algún otro comando con el output del anterior como
parámetro? Por ejemplo, el comando file muestra el tipo de archivo (ejecutable, texto ascii, etc.); puede
manipular el output para que muestre solo los nombres de archivo y ahora quiere pasar estos nombres al
comando ls -l para ver la fecha de registro. El comando xargs hace exactamente eso. Permite ejecutar
algunos otros comandos en el output. Recuerde esta sintaxis de la Parte 1:
file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr
Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando
xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos,
como si ejecutase:
alert_DBA102.log:
alert_DBA102.log.Z:
dba102_asmb_12307.trc.Z:
dba102_asmb_20653.trc.Z:
ASCII
ASCII
ASCII
ASCII
English text
text (compress'd data 16 bits)
English text (compress'd data 16 bits)
English text (compress'd data 16 bits)
xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos. Aquí se
muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z
Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando
xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos,
como si ejecutase:
ls
ls
ls
ls
-ltr
-ltr
-ltr
-ltr
alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z
xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos.
Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
$ file * | grep ASCII | cut -d":" -f1
47853 alert_DBA102.log
19 dba102_cjq0_14493.trc
29053 dba102_mmnl_14497.trc
154 dba102_reco_14491.trc
43 dba102_rvwr_14518.trc
77122 total
| xargs wc -l
(Nota: la tarea de arriba también puede lograrse con el siguiente comando:)
$ wc -l ‘file * | grep ASCII | cut -d":" -f1 | grep ASCII | cut -d":" f1‘
La versión xargs está dada para ilustrar el concepto. Linux tiene varias maneras de lograr la misma tarea; use
la que mejor se adapte a su situación.
Al utilizar este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak
La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento. La opción -t ordena a
xargs que imprima el comando antes de ejecutarlo.
Otra operación es muy útil cuando quiere abrir los archivos para edición utilizando vi:
$ file * | grep ASCII | cut -d":" -f1 | xargs vi
Este comando abre los archivos uno por uno utilizando vi. Cuando quiere buscar muchos archivos y abrirlos
para edición, esto resulta muy útil.
También tiene varias opciones. Tal vez la más útil es la opción -p, que hace que la operación sea interactiva:
$ file * | grep ASCII | cut -d":" -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_14493.trc dba102_mmnl_14497.trc
dba102_reco_14491.trc dba102_rvwr_14518.trc ?...
Aquí xarg le pide confirmación antes de ejecutar cada comando. Si presiona "y", ejecuta el comando. Le
resultará extremadamente útil cuando realice algunas operaciones potencialmente perjudiciales e irreversibles
en el archivo—como eliminar o sobrescribirlo.
La opción -t utiliza un modo verboso; despliega el comando que está por ejecutar, la cual es una opción muy
útil durante la depuración.
¿Qué sucede si el output pasara a xargs en blanco? Considere:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t wc -l
wc -l
0
$
Aquí buscar "SSSSSS" no produce ninguna concordancia; entonces el input de xargs son todos espacios en
blanco, como se muestra en la segunda línea (producida al utilizar la opción -t o verbosa). A pesar de que esto
puede ser útil, en algunos casos usted puede querer detener xargs si no hay nada que procesar; si lo hay,
puede utilizar la opción -r:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t -r wc -l
$
El comando existe si no hay nada que ejecutar.
Supongamos que quiere eliminar los archivos utilizando el comando rm, que debería ser el argumento para el
comando xargs. No obstante, rm puede aceptar una cantidad limitada de argumentos. ¿Qué sucede si su lista
de argumentos excede ese límite? La opción -n para xargs limita la cantidad de argumentos en una sola línea
de comando.
Aquí mostramos cómo puede limitar solo dos argumentos por línea de comando: Incluso si cinco líneas pasan
a xargs ls -ltr, solo dos archivos pasan a ls -ltr por vez.
$ file * | grep ASCII | cut -d":" -f1 | xargs -t -n2 ls -ltr
ls -ltr alert_DBA102.log dba102_cjq0_14493.trc
-rw-r----1 oracle
dba
738 Aug 10 19:18
dba102_cjq0_14493.trc
-rw-r--r-1 oracle
dba
2410225 Aug 13 05:31 alert_DBA102.log
ls -ltr dba102_mmnl_14497.trc dba102_reco_14491.trc
-rw-r----1 oracle
dba
5386163 Aug 10 17:55
dba102_mmnl_14497.trc
-rw-r----1 oracle
dba
6808 Aug 13 05:21
dba102_reco_14491.trc
ls -ltr dba102_rvwr_14518.trc
-rw-r----1 oracle
dba
2087 Aug 10 04:30
dba102_rvwr_14518.trc
Utilizando este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak
La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento.
rename
Como sabe, el comando mv renombra los archivos. Por ejemplo,
$ mv oldname newname
oldnamenewnamerename
rename .log .log.‘date +%F-%H:%M:%S‘ *
reemplaza todos los archivos con la extensión .log por .log.<dateformat>. Entonces sqlnet.log se convierte en
sqlnet.log.2006-09-12-23:26:28.
find
Ente los usuarios Oracle, el más conocido es el comando find. Hasta ahora, sabe cómo utilizar find para
buscar archivos en un directorio determinado. Aquí mostramos un ejemplo que comienza con la palabra "file"
en el directorio actual:
$ find . -name "file*"
./file2
./file1
./file3
./file4
No obstante, ¿qué sucede si quiere buscar nombres como FILE1, FILE2, etc.? -name "file*" no tendrá
concordancia. Para una búsqueda con distinción de mayúsculas y minúsculas, use la opción -iname:
$ find . -iname "file*"
./file2
./file1
./file3
./file4
./FILE1
./FILE2
Puede restringir su búsqueda a un tipo específico de archivos. Por ejemplo, el comando de arriba obtendrá
archivos de todo tipo: archivos comunes, directorios, enlaces simbólicos, etc. Para buscar solo archivos
comunes, puede utilizar el parámetro -type f.
$ find . -name "orapw*" -type f
./orapw+ASM
./orapwDBA102
./orapwRMANTEST
./orapwRMANDUP
./orapwTESTAUX
-type puede tomar los modificadores f (para archivos comunes), l (para enlaces simbólicos), d (directorios), b
(dispositivos de bloque), p (named pipes), c (dispositivos de caracteres), s (sockets).
Un pequeño cambio en el comando de arriba es combinarlo con el comando file que conoció en la Parte 1. El
comando file le dice qué tipo de archivo es. Puede transmitirlo como post procesador para el output desde el
comando find. El parámetro -exec ejecuta el comando que sigue el parámetro. En este caso, el comando a
ejecutar después de find es file:
$ find . -name "*oraenv*" -type f -exec file {} \;
./coraenv: Bourne shell script text executable
./oraenv: Bourne shell script text executable
Esto es útil cuando quiere descubrir si el archivo de texto ASCII podría ser algún tipo de shell script.
Si sustituye -exec con -ok, el comando es ejecutado pero solicita confirmación primero. Aquí hay un ejemplo:
$ find . -name "sqlplus*" -ok {} \;
< {} ... ./sqlplus > ? y
SQL*Plus: Release 9.2.0.5.0 - Production on Sun Aug 6 11:28:15 2006
Copyright (c) 1982, 2002, Oracle Corporation.
All rights reserved.
Enter user-name: / as sysdba
Connected to:
Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning,Real Application Clusters,OLAP
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
SQL> exit
Disconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0-64bit
Production
With the Partitioning,Real Application Clusters,OLAP
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
< È* ... ./sqlplusO > ? n
$
Aquí, hemos pedido al shell que busque todos los programas que comienzan con "sqlplus", y que los ejecute.
Fíjese que no hay nada entre -ok y {}, por lo tanto solo ejecutará los archivos que encuentre. Encuentra dos
archivos—sqlplus y sqlplusO—y en ambos casos pregunta si usted desea ejecutarlos. Respondemos "y" para
el prompt de "sqlplus" y lo ejecuta. Después de salir, solicita el segundo archivo que encontró (sqlplusO) y
solicita confirmación una y otra vez, a lo cual respondimos "n"—entonces, no se ejecutó.
Consejo para Usuarios Oracle
Oracle produce varios archivos extraños: archivos de localización, archivos testigo, archivos dump, etc. A
menos que se limpien periódicamente, pueden llenar el sistema de archivos e interrumpir la base de datos.
Para garantizar que eso no suceda, simplemente busque los archivos con extensión "trc" y elimínelos si tienen
más de tres días de antigüedad. Un comando simple es la solución:
find . -name "*.trc" -ctime +3 -exec rm {} \;
Para eliminarlos antes del límite de tres días, use la opción -f.
find . -name "*.trc" -ctime +3 -exec rm -f {} \;
Si simplemente desea enumerar los archivos:
find . -name "*.trc" -ctime +3 -exec ls -l {} \;
m4
Este comando toma un archivo input y sustituye las cadenas dentro de él con los parámetros transmitidos, lo
cual es similar a sustituirlas por variables. Por ejemplo, vea un archivo input:
$ cat temp
The COLOR fox jumped over the TYPE fence.
Si quiere sustituir las cadenas "COLOR" por "brown" y "TYPE" por "broken", puede utilizar:
$ m4 -DCOLOR=brown -DTYPE=broken temp
The brown fox jumped over the broken fence.
Else, if you want to substitute "white" and "high" for the same:
$ m4 -DCOLOR=white -DTYPE=high temp
The white fox jumped over the high fence.
whence y which
Estos comandos son utilizados para saber dónde se almacenan los ejecutables mencionados en el
PROCESO del usuario. Cuando el ejecutable es encontrado en el proceso, se comportan de manera bastante
similar y muestran el proceso:
$ which sqlplus
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
$ whence sqlplus
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
El output es idéntico. Sin embargo, si el ejecutable no es encontrado en el proceso, el comportamiento es
diferente. El comando which produce un mensaje explícito:
$ which sqlplus1
/usr/bin/which: no sqlplus1 in
(/u02/app/oracle/products/10.2.0.1/db1/bin:/usr
/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin)
whereas El comando whence no produce mensaje:
$ whence sqlplus1]
y vuelve a shell prompt. Esto es útil en casos donde el ejecutable no es encontrado en el proceso (en lugar de
mostrar el mensaje):
$ whence invalid_command
$ which invalid_command
which: no invalid_command in
(/usr/kerberos/sbin:/usr/kerberos/bin:/bin:/sbin:
/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:
/usr/bin/X11:/usr/X11R6/bin:/root/bin)
Cuando whence no encuentra un ejecutable en el proceso, vuelve sin ningún mensaje pero el código de
retorno no es cero. Esto puede utilizarse en shell scripts; por ejemplo:
RC=‘whence myexec‘
If [ $RC -ne "0" ]; then
echo "myexec is not in the $PATH"
fi
Una opción muy útil es la opción -i, que muestra el alias y el ejecutable, si está presente. Por ejemplo, usted
pudo ver el uso del alias al comienzo de este artículo. El comando rm es en realidad un alias en mi shell, y
también en cualquier lugar donde haya un comando rm en el sistema.
$ which ls /bin/ls
/bin/ls
$ which -i ls alias ls='ls --color=tty'
El comportamiento por defecto es mostrar la primera ocurrencia del ejecutable en el proceso. Si el ejecutable
existe en diferentes directorios del proceso, las ocurrencias subsiguientes son ignoradas. Puede ver todas las
ocurrencias del ejecutable mediante la opción -a.
$ which java
/usr/bin/java
$ which -a java
/usr/bin/java
/home/oracle/oracle/product/11.1/db_1/jdk/jre/bin/java
top
El comando top es probablemente el más útil para un Oracle DBA que administra una base de datos sobre
Linux. Digamos que el sistema es lento y quiere saber quién está saturando la CPU y/o memoria. Para
mostrar los procesos clave, utiliza el comando top.
Fíjese que a diferencia de otros comandos, top no produce un output y permanece inactivo. Actualiza la
pantalla para mostrar nueva información. Por lo tanto, si simplemente activa top y deja la pantalla activa,
siempre contará con la información más actual. Para cancelar e ir hacia shell, puede presionar Control-C.
$ top
18:46:13 up 11 days, 21:50, 5 users, load average: 0.11, 0.19, 0.18
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped
CPU states: cpu
user
nice system
irq softirq iowait
idle
total
12.5%
0.0%
6.7%
0.0%
0.0%
5.3%
75.2%
Mem: 1026912k av, 999548k used,
27364k free,
0k shrd, 116104k
buff
758312k actv, 145904k in_d,
16192k in_c
Swap: 2041192k av, 122224k used, 1918968k free
590140k
cached
PID USER
451 oracle
8991 oracle
1 root
2 root
3 root
4 root
ksoftirqd/0
7 root
5 root
PRI
15
15
19
15
15
34
NI
0
0
0
0
0
19
15
15
0
0
SIZE RSS SHARE STAT %CPU %MEM
6044 4928 4216 S
0.1 0.4
1248 1248
896 R
0.1 0.1
440 400
372 S
0.0 0.0
0
0
0 SW
0.0 0.0
0
0
0 SW
0.0 0.0
0
0
0 SWN
0.0 0.0
0
0
0
0
0 SW
0 SW
0.0
0.0
0.0
0.0
TIME CPU COMMAND
0:20
0 tnslsnr
0:00
0 top
0:04
0 init
0:00
0 keventd
0:00
0 kapmd
0:00
0
0:01
0:33
0 bdflush
0 kswapd
6 root
8 root
kupdated
9 root
mdrecoveryd
15
15
0
0
0
0
0
0
0 SW
0 SW
0.0
0.0
0.0
0.0
0:14
0:00
0 kscand
0
25
0
0
0
0 SW
0.0
0.0
0:00
0
... output snipped ...
Examinemos los diferentes tipos de información producidos. La primera línea:
18:46:13
up 11 days, 21:50,
5 users,
load average: 0.11, 0.19, 0.18
muestra la hora actual (18:46:13), que el sistema ha estado activo durante 11 días; que el sistema ha
trabajado durante 21 horas 50 segundos. Se muestra el promedio de carga del sistema (0.11, 0.19, 0.18) para
los últimos 1, 5 y 15 minutos respectivamente. (A propósito, usted también puede obtener esta información
ejecutando el uptime command.)
Si el promedio de carga no es necesario, presione la letra "l" (L minúscula); lo desactivará. Para volver a
activarlo presione l nuevamente. La segunda línea:
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped
muestra la cantidad de procesos, en ejecución, inactivos, etc. La tercera y cuarta línea:
CPU states:
cpu
total
user
12.5%
nice
0.0%
system
6.7%
irq
0.0%
softirq
0.0%
iowait
5.3%
idle
75.2%
muestran los detalles del uso de CPU. La línea de arriba muestra que los procesos de los usuarios consumen
un 12,5% y el sistema consume un 6,7%. Los procesos del usuario incluyen los procesos Oracle. Presione "t"
para activar y desactivar estas tres líneas. Si hay más de una CPU, usted verá una línea por CPU.
Las próximas dos líneas:
Mem:
1026912k av, 1000688k used,
758668k actv,
Swap: 2041192k av, 122476k used,
cached
26224k free,
146872k in_d,
1918716k free
0k shrd, 113624k buff
14460k in_c
591776k
muestran la memoria disponible y utilizada. La memoria total es "1026912k av", aproximadamente 1GB, de la
cual solo 26224k o 26MB está libre. El espacio de intercambio es de 2GB; pero casi no es utilizado. Para
activarlo y desactivarlo, presione "m".
El resto muestra los procesos en un formato tabular. A continuación, se explican las columnas:
Columna
Descripción
PID
El ID del proceso
USER
El usuario que ejecuta el proceso
PRI
La prioridad del proceso
NI
El valor nice: Cuanto más alto es el valor, más baja es la prioridad de la tarea
SIZE
Memoria utilizada por este proceso (código+datos+stack)
RSS
Memoria física utilizada por este proceso
SHARE
Memoria compartida utilizada por este proceso
STAT
El estado de este proceso, mostrado en códigos. Algunos códigos importantes
de estado son:
R – Running (enejecución)
S –Sleeping (inactivo)
Z – Zombie (vacilante)
T – Stopped (detenido)
Usted también puede ver el segundo y tercer carácter, que indican:
W – Swapped out process (proceso intercambiado)
N – positive nice value (valor nice positivo)
%CPU
Porcentaje de CPU utilizado por este proceso
%MEM
Porcentaje de memoria utilizado por este proceso
TIME
Tiempo total de CPU utilizado por este proceso
CPU
Si este es un proceso de procesadores múltiples, esta columna indica el ID de la
CPU sobre la cual se está ejecutando este proceso.
COMMAND
Comando utilizado por este proceso
Mientras se muestra top, puede presionar algunas teclas para formatear la representación visual como usted
quiera. Presionar la tecla mayúscula M clasifica el output por uso de memoria. (Fíjese que utilizar la letra
minúscula m activará o desactivará las líneas de resumen de memoria en la parte superior de la
representación visual). Esto es muy útil cuando quiere descubrir quién consume la memoria. Vea un ejemplo
de output:
PID USER
PRI NI SIZE RSS SHARE STAT %CPU %MEM
TIME CPU
31903 oracle
15
0 75760 72M 72508 S
0.0 7.2
0:01
ora_smon_PRODB2
31909 oracle
15
0 68944 66M 64572 S
0.0 6.6
0:03
ora_mmon_PRODB2
31897 oracle
15
0 53788 49M 48652 S
0.0 4.9
0:00
ora_dbw0_PRODB2
COMMAND
0
0
0
Ahora que ya sabe cómo interpretar el output, veamos cómo utilizar los parámetros de línea de comando.
El más útil es -d, que indica la demora entre las actualizaciones de pantalla. Para actualizar cada segundo,
use top -d 1.
La otra opción útil es -p. Si solo desea monitorear algunos procesos, no todos, puede especificar solo aquellos
después de la opción -p. Para monitorear los procesos 13609, 13608 y 13554:
top -p 13609 -p 13608 -p 13554
Esto mostrará los resultados en el mismo formato que el comando top, pero solo esos procesos específicos.
Consejo para Usuarios Oracle
Es casi innecesario decir que top resulta muy útil para analizar el desempeño de los servidores de base de
datos. Aquí mostramos un output top parcial.
20:51:14 up 11 days, 23:55, 4 users, load average: 0.88, 0.39, 0.27
113 processes: 110 sleeping, 2 running, 1 zombie, 0 stopped
CPU states: cpu
user
nice system
irq softirq iowait
idle
total
1.0%
0.0%
5.6%
2.2%
0.0%
91.2%
0.0%
Mem: 1026912k av, 1008832k used,
18080k free,
0k shrd,
30064k
buff
771512k actv, 141348k in_d,
13308k in_c
Swap: 2041192k av,
66776k used, 1974416k free
812652k
cached
PID USER
PRI
16143 oracle
15
oraclePRODB2...
5 root
15
NI SIZE
0 39280
0
0
RSS SHARE STAT %CPU %MEM
32M 26608 D
4.0 3.2
0
0 SW
1.6
0.0
TIME CPU COMMAND
0:02
0
0:33
0 kswapd
... output snipped ...
Analicemos el output cuidadosamente. Lo primero que debería notar es que la columna "inactiva" de la CPU
indica; 0,0%—es decir, la CPU está completamente ocupada haciendo algo. La pregunta es, ¿haciendo qué?
Preste atención a la columna "sistema", ligeramente a la izquierda; muestra 5,6%. Entonces el sistema no
está haciendo mucho. Vaya más a la izquierda hasta la columna "usuario", que muestra 1,0%. Como los
procesos de usuarios incluyen Oracle también, Oracle no consume los ciclos de CPU. Por lo tanto, ¿qué
consume toda la CPU?
La respuesta está en la misma línea, justo a la derecha en la columna "iowait", que indica un 91,2%. Esto lo
explica todo: la CPU está esperando IO el 91,2% del tiempo.
¿Entonces, por qué tanta espera por IO? La respuesta está en la pantalla. Fíjese en el PID del proceso con
mayor consumo: 16143. Puede utilizar la siguiente consulta para determinar qué está haciendo el proceso:
select s.sid, s.username, s.program
from v$session s, v$process p
where spid = 16143
and p.addr = s.paddr
/
SID USERNAME PROGRAM
------------------- ----------------------------159 SYS
rman@prolin2 (TNS V1-V3)
El proceso rman está reduciendo los ciclos de CPU relacionados con la espera de IO. Esta información ayuda
a determinar el próximo plan de acción.
skill y snice
En el debate anterior, aprendió cómo identificar un recurso de consumo de CPU. ¿Qué sucede si descubre
que un proceso consume mucha CPU y memoria, pero no quiere cancelarlo? Considere este output top:
$ top -c -p 16514
23:00:44 up 12 days, 2:04, 4 users, load average: 0.47, 0.35, 0.31
1 processes: 1 sleeping, 0 running, 0 zombie, 0 stopped
CPU states: cpu
user
nice system
irq softirq iowait
idle
total
0.0%
0.6%
8.7%
2.2%
0.0%
88.3%
0.0%
Mem: 1026912k av, 1010476k used,
16436k free,
0k shrd,
52128k
buff
766724k actv, 143128k in_d,
14264k in_c
Swap: 2041192k av,
83160k used, 1958032k free
799432k
cached
PID USER
PRI
16514 oracle
19
oraclePRODB2...
NI SIZE
4 28796
RSS SHARE STAT %CPU %MEM
26M 20252 D N
7.0 2.5
TIME CPU COMMAND
0:03
0
Ahora que confirmó que el proceso 16514 consume mucha memoria, puede "congelarlo"—pero no
cancelarlo—usando el comando skill.
$ skill -STOP 1
Luego, vea el output top:
23:01:11 up 12 days, 2:05, 4 users, load average: 1.20, 0.54, 0.38
1 processes: 0 sleeping, 0 running, 0 zombie, 1 stopped
CPU states: cpu
user
nice system
irq softirq iowait
idle
total
2.3%
0.0%
0.3%
0.0%
0.0%
2.3%
94.8%
Mem: 1026912k av, 1008756k used,
18156k free,
0k shrd,
3976k
buff
770024k actv, 143496k in_d,
12876k in_c
Swap: 2041192k av,
83152k used, 1958040k free
851200k
cached
PID USER
PRI
16514 oracle
19
oraclePRODB2...
NI SIZE
4 28796
RSS SHARE STAT %CPU %MEM
26M 20252 T N
0.0 2.5
TIME CPU COMMAND
0:04
0
La CPU ahora está un 94% inactiva, de 0%. El proceso queda efectivamente congelado. Después de algún
tiempo, puede querer reanudar el proceso del coma:
$ skill -CONT 16514
Este enfoque es muy útil para congelar temporalmente los procesos a fin de hacer lugar para finalizar los
procesos más importantes.
El comando es muy versátil. Si desea detener todos los procesos de usuario "oracle", hay únicamente un solo
comando que lo hace todo:
$ skill -STOP oracle
Puede utilizar un usuario, PID, un comando o terminal id como argumento. Lo que se muestra a continuación
detiene todos los comandos rman.
$ skill -STOP rman
Como puede ver, skill decide ese argumento que ingresó—un ID para el proceso, un id de usuario o un
comando—y actúa en consecuencia. Esto puede causar problemas en algunos casos, donde puede tener un
usuario y un comando con el mismo nombre. El mejor ejemplo es el proceso "oracle", que en general es
ejecutado por el usuario "oracle". Por lo tanto, cuando quiere detener el proceso denominado "oracle" y
realiza:
$ skill -STOP oracle
todos los procesos del usuario "oracle" se detienen, incluso la sesión que puede estar ejecutando en ese
momento. Para ser completamente ambiguo, puede opcionalmente ofrecer un nuevo parámetro para
especificar el tipo de parámetro. Para detener un comando llamado oracle, puede:
$ skill -STOP -c oracle
El comando snice es similar. En lugar de detener un proceso, hace que su prioridad sea más baja. Primero,
vea el output:
PID
3
13680
13683
13686
13689
13695
13698
13701
USER
root
oracle
oracle
oracle
oracle
oracle
oracle
oracle
PRI
15
15
15
15
15
15
15
15
NI
0
0
0
0
0
0
0
0
SIZE
0
11336
9972
9860
10004
9984
10064
22204
RSS SHARE STAT %CPU %MEM
0
0 RW
0.0 0.0
10M 8820 T
0.0 1.0
9608 7788 T
0.0 0.9
9496 7676 T
0.0 0.9
9640 7820 T
0.0 0.9
9620 7800 T
0.0 0.9
9700 7884 T
0.0 0.9
21M 16940 T
0.0 2.1
TIME CPU COMMAND
0:00
0 kapmd
0:00
0 oracle
0:00
0 oracle
0:00
0 oracle
0:00
0 oracle
0:00
0 oracle
0:00
0 oracle
0:00
0 oracle
Ahora, reduzca cuatro puntos la prioridad de los procesos de "oracle". Fíjese que cuanto mayor es el número,
más baja es la prioridad.
$ snice +4 -u oracle
PID USER
16894 oracle
PRI
20
NI SIZE
4 38904
RSS SHARE STAT %CPU %MEM
32M 26248 D N
5.5 3.2
TIME CPU COMMAND
0:01
0 oracle
Guía para Maestría Avanzada en Comandos Linux, Parte 3:
Administración de Recursos
por Arup Nanda
Publicado en mayo de 2009
En esta entrega, aprenda los comandos avanzados de Linux para monitorear componentes físicos
Un sistema Linux está conformado por varios componentes físicos clave como CPU, memorias, tarjetas de red
y dispositivos de almacenamiento. Para administrar de manera efectiva el entorno Linux, usted debería poder
evaluar varias métricas de estos recursos—cuánto procesa cada componente, si existen cuellos de botella,
entre otras cosas —con una precisión razonable.
En otras partes de esta serie usted aprendió algunos comandos para medir las métricas en un nivel macro. En
esta entrega, no obstante, aprenderá los comandos avanzados de Linux para monitorear componentes físicos.
En especial, aprenderá acerca de los comandos en las siguientes categorías:
Component
Commands
Memory
free, vmstat, mpstat, iostat, sar
CPU
vmstat, mpstat, iostat, sar
I/O
vmstat, mpstat, iostat, sar
Processes
ipcs, ipcrm
Como puede observar, algunos comandos aparecen en más de una categoría. Esto se debe a que los
comandos pueden desempeñar muchas tareas. Algunos comandos se ajustan mejor a otros componentes –
por ej., iostat para I/O—pero debería comprender las diferencias en sus trabajos y utilizar aquellos con los que
se sienta más cómodo.
En la mayoría de los casos, un solo comando no es útil para comprender lo que realmente está sucediendo.
Usted debería conocer múltiples comandos para obtener la información que desea.
"free"
Una pregunta común es, “¿Cuánta memoria está siendo utilizada por mis aplicaciones y los distintos
servidores, usuarios y procesos de sistemas?” O, “¿Cuánto espacio de memoria tengo libre en este
momento?” Si la memoria utilizada por los procesos en ejecución es mayor la memoria RAM disponible, los
procesos se trasladan a la memoria swap (memoria virtual). Por lo tanto, una pregunta complementaria sería,
“¿Qué cantidad de memoria swap se está utilizando?”.
El comando “free” responde a todas estas preguntas. Es más, una opción muy útil, –m , muestra la memoria
libre en megabytes:
# free -m
total
Mem:
1772
-/+ buffers/cache:
Swap:
1983
used
1654
1017
1065
free
117
754
918
shared
0
buffers
18
cached
618
El output muestra que el sistema tiene 1.772 MB de RAM, de los cuales se utilizan 1.654 MB, dejando 117 MB
de memoria libre. La segunda línea muestra los cambios de tamaño de caché y buffers en la memoria física.
La tercera línea muestra la utilización de memoria swap.
Para expresar lo mismo en kilobytes y gigabytes, reemplace la opción -m con -k o -g respectivamente. Usted
puede colocarse en el nivel de bytes también, utilizando la opción –b.
# free -b
total
used
Mem:
1858129920 1724039168
-/+ buffers/cache: 1062203392
Swap:
2080366592 1116721152
free
134090752
795926528
963645440
shared
0
buffers
18640896
cached
643194880
La opción –t muestra el total al final del output (suma de memoria física más swap):
# free -m -t
total
Mem:
1772
-/+ buffers/cache:
Swap:
1983
Total:
3756
used
1644
1014
1065
2709
free
127
757
918
1046
shared
0
buffers
16
cached
613
A pesar de que “free” no muestra los porcentajes, podemos extraer y formatear partes específicas del output
para mostrar la memoria utilizada como porcentaje del total solamente:
# free -m | grep Mem | awk '{print ($3 / $2)*100}'
98.7077
Esto viene bien para los shell scripts en donde las cantidades específicas son importantes. Por ejemplo, usted
quizás quiera generar un alerta cuando el porcentaje de memoria libre descienda por debajo de cierto límite.
De modo similar, para encontrar el porcentaje de swap utilizado, usted puede emitir:
free -m | grep -i Swap | awk '{print ($3 / $2)*100}'
Puede utilizar free para observar la carga de memoria empleada por una aplicación. Por ejemplo, controle la
memoria libre antes de iniciar una aplicación de backup y luego contrólela inmediatamente luego de iniciarla.
La diferencia podría atribuirse al consumo por parte de la aplicación de backup.
Para Usuarios de Oracle
Entonces, ¿cómo puede utilizar este comando para administrar el servidor Linux que ejecuta su entorno de
Oracle? Una de las causas más comunes de los problemas de desempeño es la falta de memoria, lo que
provoca que el sistema “intercambie” áreas de memoria en el disco de manera temporal. Cierto grado de
intercambio es probablemente inevitable pero experimentar una gran cantidad de intercambio puede indicar
falta de memoria libre.
En cambio, usted puede utilizar free para obtener información de la memoria libre y ahora hacer el
seguimiento con el comando sar (que se muestra luego) para controlar la tendencia histórica del consumo de
memoria y swap. Si el uso de swap es temporario, es probable que se trate de un pico (spike) por única vez;
pero si se declara durante un período de tiempo, debería hacerlo notar. Existen algunas sospechas posibles y
obvias de sobrecarga crónica de memoria:



SGA más amplia que la memoria disponible
Amplia asignación en PGA
Algunos procesos con bugs que producen la fuga de de memoria
Para el primer caso, usted debería asegurarse de que SGA sea menor a la memoria disponible. La regla
general es utilizar alrededor del 40 por ciento de la memoria física para SGA, no obstante, debería definir ese
parámetro sobre la base de su situación específica. En el segundo caso, usted debería intentar reducir la
amplia asignación de buffers en consultas. En el tercer caso debería utilizar el comando “ps” (descripto en
entregas anteriores de esta serie) para identificar el proceso específico que podría producir la fuga de
memoria.
"ipcs"
Cuando se ejecuta un proceso, se adopta desde la “memoria compartida”. Puede haber uno o muchos
segmentos de memoria compartida por proceso. Los procesos intercambian mensajes entre ellos
(“comunicaciones entre procesos”, o IPC) y utilizan semáforos. Para desplegar información sobre segmentos
de memoria compartida, colas de mensajes IPC y semáforos, usted puede utilizar un solo comando: ipcs.
La opción –m es muy conocida; despliega los segmentos de memoria compartida.
# ipcs -m
------ Shared Memory Segments -------key
shmid
owner
perms
0xc4145514 2031618
oracle
660
0x00000000 3670019
oracle
660
0x00000000 327684
oracle
600
0x00000000 360453
oracle
600
0x00000000 393222
oracle
600
0x00000000 425991
oracle
600
0x00000000 3702792
oracle
660
0x00000000 491529
oracle
600
0x49d1a288 3735562
oracle
660
0x00000000 557067
oracle
600
0x00000000 1081356
oracle
600
0x00000000 983053
oracle
600
0x00000000 1835023
oracle
600
bytes
4096
8388608
196608
196608
196608
196608
926941184
196608
140509184
196608
196608
196608
196608
nattch
0
108
2
2
2
2
108
2
108
2
2
2
2
status
dest
dest
dest
dest
dest
dest
dest
dest
dest
Este output, tomado de un servidor que ejecuta software de Oracle, muestra los distintos segmentos de
memoria compartida. Cada uno se identifica exclusivamente por un ID de memoria compartida, y se muestra
en la columna “shmid”. (Más adelante verá cómo utilizar el valor de esta columna.) El “owner”, por supuesto,
muestra el propietario del segmento, la columna “perms” muestra los permisos (igual que los permisos unix), y
“bytes” muestra el tamaño de los bytes.
La opción -u muestra un breve resumen:
# ipcs -mu
------ Shared Memory Status -------segments allocated 25
pages allocated 264305
pages resident 101682
pages swapped
100667
Swap performance: 0 attempts
0 successes
La opción –l muestra los límites (en contraposición a los valores actuales):
# ipcs -ml
------ Shared Memory Limits -------max number of segments = 4096
max seg size (kbytes) = 907290
max total shared memory (kbytes) = 13115392
min seg size (bytes) = 1
Si usted ve que los valores reales se acercan o se encuentran en el límite, debería extender ese límite.
Puede obtener un panorama detallado de un segmento de memoria compartida utilizando el valor shmid. La
opción –i logra esto. Usted verá los detalles de shmid 3702792:
# ipcs -m -i 3702792
Shared memory Segment shmid=3702792
uid=500 gid=502 cuid=500
cgid=502
mode=0660
access_perms=0660
bytes=926941184 lpid=12225
cpid=27169
att_time=Fri Dec 19 23:34:10 2008
det_time=Fri Dec 19 23:34:10 2008
change_time=Sun Dec 7 05:03:10 2008
nattch=113
Más adelante verá un ejemplo de cómo interpretar el output de arriba.
La opción -s muestra los semáforos en el sistema:
# ipcs -s
------ Semaphore Arrays -------key
semid
owner
perms
0x313f2eb8 1146880
oracle
660
0x0b776504 2326529
oracle
660
… and so on …
nsems
104
154
Esto muestra algunos de datos valiosos. Se observa que el grupo de semáforos de ID 1146880 posee 104
semáforos, y el otro tiene 154. Si usted los suma, el valor total debe ser menor al límite máximo definido por el
parámetro kernel (semmax). Mientras se instala el software de la Base de Datos de Oracle, el controlador de
preinstalación debe controlar los parámetros para semmax. Luego, cuando el sistema alcanza el estado
seguro, usted puede controlar la utilización real y luego ajustar el valor kernel de manera adecuada.
Para Usuarios de Oracle
¿Cómo puede descubrir los segmentos de memoria compartida utilizados por la instancia de Base de Datos
de Oracle? Para lograrlo, utilice el comando oradebug. Primero conéctese a la base de datos como sysdba:
# sqlplus / as sysdba
En el SQL, utilice el comando oradebug como se muestra abajo:
SQL> oradebug setmypid
Statement processed.
SQL> oradebug ipc
Information written to trace file.
Para descubrir el nombre del archivo de rastreo:
SQL> oradebug TRACEFILE_NAME
/opt/oracle/diag/rdbms/odba112/ODBA112/trace/ODBA112_ora_22544.trc
Ahora, si abre un archivo de rastreo, usted verá los IDs de la memoria compartida. Aquí se muestra un
extracto del archivo:
Area #0 `Fixed Size' containing Subareas 0-0
Total size 000000000014613c Minimum Subarea size 00000000
Area Subarea
Shmid
Stable Addr
Actual Addr
0
0 17235970 0x00000020000000 0x00000020000000
Subarea size
Segment size
0000000000147000 000000002c600000
Area #1 `Variable Size' containing Subareas 4-4
Total size 000000002bc00000 Minimum Subarea size 00400000
Area Subarea
Shmid
Stable Addr
Actual Addr
1
4 17235970 0x00000020800000 0x00000020800000
Subarea size
Segment size
000000002bc00000 000000002c600000
Area #2 `Redo Buffers' containing Subareas 1-1
Total size 0000000000522000 Minimum Subarea size 00000000
Area Subarea
Shmid
Stable Addr
Actual Addr
2
1 17235970 0x00000020147000 0x00000020147000
Subarea size
Segment size
0000000000522000 000000002c600000
... and so on ...
El ID de memoria compartida se muestra en letra mayúsculas rojas. Usted puede utilizar este ID de memoria
compartida para obtener los detalles de la memoria compartida:
# ipcs -m -i 17235970
Otra observación útil es el valor de lpid – el ID del proceso que por última vez alcanzó el segmento de
memoria compartida. Para demostrar el valor en ese atributo, utilice SQL*Plus para conectarse a la instancia
desde una sesión distinta.
# sqlplus / as sysdba
En esa sesión, descubra el PID del proceso del servidor:
SQL> select spid from v$process
2 where addr = (select paddr from v$session
3
where sid =
4
5
(select sid from v$mystat where rownum < 2)
);
SPID
-----------------------13224
Ahora vuelva a ejecutar el comando “ipcs” frente al mismo segmento de memoria compartida:
# ipcs -m -i 17235970
Shared memory Segment shmid=17235970
uid=500 gid=502 cuid=500
cgid=502
mode=0660
access_perms=0660
bytes=140509184 lpid=13224
cpid=27169
att_time=Fri Dec 19 23:38:09 2008
det_time=Fri Dec 19 23:38:09 2008
change_time=Sun Dec 7 05:03:10 2008
nattch=113
Preste atención al valor de “lpid”, que fue cambiado a 13224 desde el valor original 12225. El “lpid” muestra el
PID del último proceso que alcanzó el segmento de memoria compartida, y observe cómo cambiaron los
valores.
El comando por sí mismo, ofrece poco valor. El próximo comando – ipcrm – le permite actuar en base al
output, como verá en la próxima sección.
ipcrm
Ahora que ha identificado la memoria compartida y demás métricas de IPC ¿qué hacer con ellas? Usted ya ha
conocido su uso, por ejemplo, identificar le memoria compartida utilizada por Oracle, asegurar que el
parámetro kernel para la memoria compartida haya sido establecido, etc. Otra aplicación común es eliminar la
memoria compartida, la cola de mensajes IPC, o los grupos de semáforos.
Para eliminar el segmento de memoria compartida, observe su “shmid” del output del comando “ipcs”. Luego
utilice la opción –m para eliminar el segmento. Para remover el segmento con ID 3735562, utilice
# ipcrm –m 3735562
Esto eliminará la memoria compartida. Usted también puede utilizarlo para eliminar colas de mensajes IPC y
semáforos (utilizando los parámetros –s y –q).
Para Usuarios de Oracle
Algunas veces cuando se cierra la instancia de base de datos, los segmentos de memoria compartida pueden
no eliminarse por completo por el kernel de Linux. La memoria compartida que queda no es utilizada; no
obstante, invade los recursos del sistema reduciendo la cantidad de memoria disponible para otros procesos.
En ese caso, usted puede controlar cualquier segmento de memoria compartida persistente que posee el
usuario “oracle” y luego eliminarlo, si corresponde, utilizando el comando ”ipcrm”.
vmstat
Cuando se invoca vmstat, denominado el “abuelo” de todas las visualizaciones relacionadas con procesos y
memorias, continuamente ejecuta y entrega su información. Toma dos segmentos:
# vmstat <interval> <count>
<interval> es el intervalo en segundos entre dos ejecuciones. <count> es la cantidad de repeticiones que
vmstat realiza. Vea un ejemplo de cuando usted desea que vmstat se ejecute cada cinco segundos y se
detenga luego de la décima vez. Cada línea en el output se despliega después de cinco segundos y muestra
las estadísticas en ese momento.
# vmstat 5 10
procs -----------memory---------- --swap-- ----io---- --system-- ---cpu---r b
swpd
free
buff cache si
so
bi
bo
in
cs us sy
id wa
0 0 1087032 132500 15260 622488 89
19
9
3
0
0 4 10
82 5
0 0 1087032 132500 15284 622464
0
0 230
151 1095
858 1 0
98 1
0 0 1087032 132484 15300 622448
0
0 317
79 1088
905 1 0
98 0
… shows up to 10 times.
El output muestra mucha información sobre los recursos del sistema. Veámoslos en detalle:
procs Muestra la cantidad de procesos
r
Proceso en espera para ser ejecutado. Cuanto mayor es la carga del sistema, mayor la
cantidad de procesos que esperan que los ciclos de CPU se ejecuten.
b
Procesos en espera ininterrumpible, también conocidos como procesos “bloqueados”. Estos
procesos generalmente esperan una I/O, pero también podrían referirse a otras cosas.
Algunas veces hay otra columna que se denomina “w”, la cual muestra la cantidad de procesos que pueden
ser ejecutados pero que se han intercambiado al área de swap.
La cantidad que muestra “b” debería ser cercana a 0. Si la cantidad que se muestra en “w” es elevada, usted
puede necesitar más memoria.
El siguiente cuadro muestra las métricas de memoria::
swpd
Cantidad de memoria virtual o memoria swap (en KB)
free
Cantidad de memoria física libre (en KB)
buff
Cantidad de memoria utilizada como buffer (en KB)
cache
Kilobytes de memoria física utilizados como caché
La memoria de buffer se utiliza para almacenar metadatos de archivos como i-nodes y datos de dispositivos
de bloques en bruto. La memoria de caché se utiliza para datos de archivos.
El siguiente cuadro muestra la actividad de swap:
si Índice en el cual la memoria realiza el intercambio del disco a la RAM física (en KB/seg.)
so Índice en el cual la memoria realiza el intercambio al disco desde la memoria RAM física (en
KB/seg.)
El siguiente cuadro muestra la actividad de I/O:
bi Índice en el cual el sistema envía datos a los dispositivos de bloque (en bloques/seg.)
bo Índice en el cual el sistema lee los datos desde los dispositivos de bloque (en bloques/seg.)
El siguiente cuadro muestra las actividades relacionadas con el sistema:
in
Cantidad de interrupciones del sistema por segundo
cs Índice de cambios de contexto en el espacio del proceso (en cantidad /seg.)
El último cuadro es probablemente el más utilizado –información sobre la carga de CPU:
us Muestra el porcentaje de CPU utilizado en los procesos del usuario. Los procesos de Oracle se
presentan en esta categoría.
sy Porcentaje de CPU utilizado por los procesos del sistema, tales como los procesos de raíz
id Porcentaje de CPU libre
wa Porcentaje utilizado en “espera por I/O”
Veamos cómo interpretar estos valores. La primera línea del output es un promedio de todas las métricas
desde el reinicio del sistema. Por lo tanto, ignore esa línea ya que no muestra el estado real. Las demás
líneas muestran las métricas en tiempo real.
De modo ideal, la cantidad de procesos en espera o bloqueados (bajo el encabezado “procs”) debería ser 0
o cercana a 0. Si ésta es elevada, entonces el sistema no tiene demasiados recursos como CPU, memoria o
I/O. Esta información resulta útil al momento de diagnosticar los problemas de desempeño.
Los datos bajo “swap” indican si se está produciendo un exceso de intercambio. Si ese es el caso, entonces
quizás tenga memoria física inadecuada. Usted debería reducir la demanda de memoria o aumentar la
memoria RAM física.
Los datos bajo “io” indican el flujo de datos desde y hasta el disco. Esto muestra la actividad del disco, sin
indicar necesariamente la existencia de algún problema. Si usted observa un número elevado en “proc” y
luego en la columna “b” (procesos que están siendo bloqueados) y I/O elevado, el problema podría deberse a
una contención I/O severa.
La información más útil se presenta en el encabezado “cpu”. La columna “id” muestra la CPU inactiva. Si
usted resta 100 a esa cantidad, obtiene el porcentaje de CPU ocupada. ¿Recuerda el comando “top” descripto
en otra entrega de esta serie? Ese también muestra el porcentaje de CPU libre. La diferencia es: el comando
“top” muestra el porcentaje libre para cada CPU mientras que el vmstat muestra la visión consolidada de todas
las CPU.
El comando “vmstat” también muestra el desglose del uso de CPU: qué cantidad es utilizada por el sistema
Linux, qué cantidad por un proceso de usuarios y por la espera para I/O. A partir de este desglose usted
puede determinar qué contribuye al consumo de la CPU. Si la carga del sistema de CPU es alta, ¿podría
haber algún proceso raíz como un backup en ejecución?
La carga del sistema debería ser consistente durante un período de tiempo. Si el sistema muestra una
cantidad elevada, utilice el comando “top” para identificar el porcentaje de consumo de CPU.
Para Usuarios de Oracle
Los procesos de Oracle (los procesos de antecedentes y del servidor) y los procesos de usuarios (sqlplus,
apache, etc.) figuran bajo “us”. Si esta cantidad es elevada, utilice “top” para identificar los procesos. Si la
columna “wa” muestra una cantidad elevada, esto indica que el sistema I/O no puede alcanzar la cantidad de
lectura o escritura. Esto podría ocasionalmente disparar un resultado de picos en actualizaciones a la base de
datos, lo que podría causar un cambio de registro y un pico posterior en los procesos de archivo. Pero, si
muestra consistentemente una cifra elevada, entonces podría estar en presencia de un cuello de botella de
I/O.
Las obstrucciones de I/O en una base de datos de Oracle pueden causar serios problemas. Aparte de los
problemas de desempeño, el lento flujo de I/O podría provoca enlentecer las escrituras de “controlfile”, lo que
provocaría la espera de un proceso hasta adquirir “controlfile” en cola. Si la espera es de más de 900
segundos, y un proceso crítico está en espera, como LGWR, se elimina la instancia de base de datos.
Si el nivel de intercambio (swapping) es elevado, tal vez el tamaño de SGA sea muy alto para ajustarse a la
memoria física. Usted debería reducir el tamaño de SGA o aumentar la memoria física.
mpstat
Otro comando útil para obtener las estadísticas relacionadas con la CPU es “mpstat”. Aquí se muestra un
ejemplo del output:
# mpstat -P ALL 5 2
Linux 2.6.9-67.ELsmp (oraclerac1)
12/20/2008
10:42:38PM
10:42:43PM
10:42:43PM
10:42:43PM
CPU
all
0
1
%user %nice %system %iowait %irq %soft
6.89 0.00
44.76
0.10 0.10 0.10
9.20 0.00
49.00
0.00 0.00 0.20
4.60 0.00
40.60
0.00 0.20 0.20
%idle
48.05
41.60
54.60
intr/s
1121.60
413.00
708.40
10:42:43PM
10:42:48PM
10:42:48PM
10:42:48PM
CPU
all
0
1
%user %nice %system %iowait %irq %soft
7.60 0.00
45.30
0.30 0.00 0.10
4.19 0.00
2.20
0.40 0.00 0.00
10.78 0.00
88.22
0.40 0.00 0.00
%idle
46.70
93.21
0.20
intr/s
1195.01
1034.53
160.48
Average:
Average:
Average:
Average:
CPU
all
0
1
%user %nice %system %iowait %irq %soft
7.25 0.00
45.03
0.20 0.05 0.10
6.69 0.00
25.57
0.20 0.00 0.10
7.69 0.00
64.44
0.20 0.10 0.10
%idle
47.38
67.43
27.37
intr/s
1158.34
724.08
434.17
Muestra las distintas estadísticas para las CPU del sistema. Las opciones –P ALL ordena al comando
desplegar las estadísticas de todas las CPU, no solamente de una específica. Los parámetros 5 2 ordenan al
comando ejecutarse cada 5 segundos y durante 2 veces. El output de arriba muestra las métricas para todas
las primeras CPU (agrupadas) y para cada CPU individualmente. Finalmente, el porcentaje para todas las
CPU se muestra al final.
Veamos el significado de los valores de las columnas:
%user
Indica el porcentaje de procesamiento para la CPU consume por proceso de usuario. Los
procesos de usuarios son procesos que no son kernel utilizados para aplicaciones como las
de la base de datos de Oracle. En este output de ejemplo, el porcentaje de CPU de usuario
es muy pequeño.
%nice
Indica el porcentaje de CPU cuando un proceso ha bajado su categoría por el comando
nice. El comando nice ha sido descripto en una entrega anterior. En resumen, el comando
nice cambia la prioridad de un proceso.
%system Indica el porcentaje de CPU utilizado por los procesos kernel
%iowait
Muestra el porcentaje de tiempo de CPU utilizado por la espera de I/O
%irq
Indica el porcentaje de CPU utilizado para manejar las interrupciones del sistema
%soft
Indica el porcentaje utilizado para las interrupciones de software
%idle
Muestra el tiempo de inactividad de la CPU
%intr/s
Muestra la cantidad total de interrupciones que la CPU recibe por segundo
Usted podría preguntarse cuál es el propósito del comando mpstat cuando usted ya posee vmstat, descripto
anteriormente. Existe una gran diferencia: mpstat puede mostrar las estadísticas por procesador, mientras que
vmstat ofrece una visión consolidada de todos los procesadores. Por lo tanto, es posible que una aplicación
escasamente escrita que no utilice una arquitectura de múltiples threads se ejecute sobre un motor de
múltiples procesadores pero que no utilice todos los procesadores. Como resultado, se produce la sobrecarga
de una CPU mientras que las demás permanecen libres. Usted puede diagnosticar fácilmente estas clases de
problemas por medio de mpstat.
Para Usuarios de Oracle
De modo similar a vmstat, el comando mpstat también produce estadísticas relacionadas con la CPU de
manera que todos los debates relacionados con los problemas de CPU también se aplican a mpstat. Cuando
usted observa un bajo nivel de %idle, sabe que está en presencia de una insuficiencia de CPU. Cuando
observa una cantidad de %iowait mayor, usted sabe que existe algún problema con el subsistema I/O en torno
a la carga actual. Esta información resulta útil para resolver rápidamente los problemas de desempeño de la
base de datos de Oracle.
iostat
Una parte clave de la evaluación de desempeño es el desempeño del disco. El comando iostat brinda las
métricas de desempeño de las interfaces de almacenamiento.
# iostat
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
avg-cpu:
%user
15.71
Device:
cciss/c0d0
cciss/c0d0p1
%nice
0.00
tps
4.85
0.08
%sys %iowait
1.07
3.30
Blk_read/s
34.82
0.21
12/27/2008
%idle
79.91
Blk_wrtn/s
130.69
0.00
Blk_read
Blk_wrtn
307949274 1155708619
1897036
3659
cciss/c0d0p2
18.11
cciss/c0d1
0.96
cciss/c0d1p1
2.67
sda
0.00
sdb
1.03
sdc
0.00
sdd
1.74
sde
0.00
sdf
1.51
sdg
0.00
... and so on ...
34.61
13.32
13.32
0.00
5.94
0.00
38.19
0.00
34.90
0.00
130.69
19.75
19.75
0.00
18.84
0.00
11.49
0.00
6.80
0.00
306051650 1155700792
117780303 174676304
117780007 174676288
184
0
52490104 166623534
184
0
337697496 101649200
184
0
308638992
60159368
184
0
La primera parte del output muestra las métricas como el espacio de CPU libre y las esperas I/O como ha
podido ver en el comando mpstat.
La próxima parte del output muestra métricas muy importantes para cada uno de los dispositivos de disco en
el sistema. Veamos lo que significan estas columnas:
Device
Nombre del dispositivo
tps
Cantidad de transferencias por segundo, es decir, cantidad de operaciones I/O por
segundo. Nota: esta es solamente la cantidad de operaciones I/O; cada operación podría
ser extensa o pequeña.
Blk_read/s
Cantidad de bloques leídos desde este dispositivo por segundo. Generalmente los
bloques tienen un tamaño de 512 bytes. Este es el mejor valor de utilización de disco.
Blk_wrtn/s
Cantidad de bloques escritos en este dispositivo por segundo
Blk_read
Cantidad de bloques leídos desde este dispositivo al momento. Preste atención; no se
refiere a lo que está sucediendo en ese momento. Estos bloques ya fueron leídos desde
el dispositivo. Es posible que no se esté leyendo nada en ese momento. Observe esto
por un rato para ver si se producen cambios.
Blk_wrtn
Cantidad de bloques escritos en el dispositivo
En un sistema con muchos dispositivos, el output podría aparecer a través de varias pantallas—haciendo que
las cosas sean un poco difícil de examinar, especialmente si busca un dispositivo específico. Usted puede
obtener las métricas para un dispositivo específico solamente utilizando ese dispositivo como parámetro.
# iostat sdaj
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
avg-cpu:
Device:
sdaj
%user
15.71
tps
1.58
%nice
0.00
%sys %iowait
1.07
3.30
Blk_read/s
31.93
Blk_wrtn/s
10.65
12/27/2008
%idle
79.91
Blk_read
282355456
Blk_wrtn
94172401
Las métricas de CPU mostradas al comienzo pueden no ser demasiado útiles. Para eliminar las estadísticas
relacionadas con la CPU en el comienzo del output, utilice la opción -d.
Usted puede establecer parámetros adicionales al final para que iostat despliegue las estadísticas de
dispositivo en intervalos regulares. Para obtener las estadísticas para este dispositivo cada 5 segundos
durante 10 veces, emita lo siguiente:
# iostat -d sdaj 5 10
You can display the stats in kilobytes instead of just bytes
using the -k option:
# iostat -k -d sdaj
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
Device:
sdaj
tps
1.58
kB_read/s
15.96
12/27/2008
kB_wrtn/s
5.32
kB_read
141176880
kB_wrtn
47085232
A pesar de que el output de arriba puede ser útil, aún queda demasiada información que no está lista para ser
desplegada. Por ejemplo, una de las causas de los problemas de disco es el tiempo de servicio de disco, es
decir, la rapidez con la que el disco obtiene los datos para el proceso que los pide. Para alcanzar ese nivel de
métricas, debemos obtener las estadísticas “extendidas” en el disco, utilizando la opción -x.
# iostat -x sdaj
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
avg-cpu:
Device:
sdaj
%user
15.71
%nice
0.00
rrqm/s wrqm/s
0.00
0.00
12/27/2008
%sys %iowait
1.07
3.30
r/s
1.07
w/s
0.51
Device: wkB/s avgrq-sz avgqu-sz
sdaj
5.32
27.01
0.01
%idle
79.91
rsec/s
31.93
await
6.26
wsec/s
10.65
svctm
6.00
rkB/s ...
15.96 ...
%util
0.95
Veamos el significado de las columnas:
Device
Nombre del dispositivo
rrqm/s
Cantidad de solicitudes de lectura fusionas por segundo. Las solicitudes de disco que se
colocan en cola. Cuando es posible, kernel intenta fusionar varias solicitudes en una. Esta
métrica mide las transferencias de fusión de las solicitudes de lectura.
wrqm/s
Similar a la de lectura, esta es la cantidad de solicitudes de escritura fusionadas.
r/s
Cantidad de solicitudes de lectura por segundo emitidas en este dispositivo
w/s
Del mismo modo, se refiere a la cantidad de solicitudes de escritura por segundo
rsec/s
Cantidad de sectores leídos desde este dispositivo por segundo
wsec/s
Cantidad de sectores escritos en el dispositivo por segundo
rkB/s
Datos leídos por segundo desde este dispositivo, en kilobytes por segundo
wkB/s
Datos escritos en este dispositivo, en kb/s
avgrq-sz Tamaño promedio de solicitudes de lectura, en sectores
avgqusz
Longitud promedio de la cola de solicitudes para este dispositivo
await
Promedio de tiempo transcurrido (en milisegundos) para el dispositivo de solicitudes I/O.
Esto es la suma del tiempo de servicio + el tiempo de espera en cola.
svctm
Promedio del tiempo de servicio (en milisegundos) del dispositivo
%util
Utilización de ancho de banda del dispositivo. Si es cercano al 100%, el dispositivo está
saturado.
Ahora bien, tanta información puede presentar un desafío sobre cómo utilizarla de manera efectiva. La
próxima sección muestra cómo utilizar el output.
Cómo Utilizarlo
Puede utilizar una combinación de comandos para obtener información del output. Recuerde, los discos
podrían demorar en obtener la solicitud de los procesos. La cantidad de tiempo que le lleva al disco obtener
los datos desde el disco y hasta la cola se denomina tiempo de servicio. Si desea ver los discos con los
tiempos de servicio más elevados, usted debe emitir:
# iostat -x | sort -nrk13
sdat
0.00
0.00 0.00
sdv
0.00
0.00 0.00
sdak
0.00
0.00 0.00
sdm
0.00
0.00 0.00
sdat
0.00
18.80
sdv
0.00
17.16
sdak
0.55
8.02
sdm
0.76
8.06
... and so on ...
0.00
0.00
0.14
0.19
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.01
64.06
18.03
17.00
16.78
0.00
0.00
1.11
1.52
64.05
17.64
17.00
16.78
0.00
0.00
0.00
0.01
0.00
0.00
0.24
0.32
...
...
...
...
Esto muestra que el sdat de disco tiene el tiempo de servicio más elevado (64.05 ms). ¿Por qué es tan alto?
Puede haber varias posibilidades pero posiblemente éstas sean las tres más importantes:
1.
2.
3.
El disco contiene muchas solicitudes, por lo tanto el tiempo de servicio promedio es alto
El disco está utilizando el máximo de ancho de banda.
El disco es inherentemente lento.
Al observar el output vemos que reads/sec y writes/sec es de 0.00 (no sucede prácticamente nada), por lo
tanto podemos excluir la #1. La utilización también es de 0.00% (la última columna), por lo tanto podemos
excluir la #2. Así queda la #3. No obstante, antes de llegar a la conclusión de que el disco es inherentemente
lento, necesitamos observar aquel disco un poco más de cerca. Podemos examinar ese disco solo cada 5
segundos, unas 10 veces.
# iostat -x sdat 5 10
Si el output muestra el mismo porcentaje de tiempo de servicio, los mismos índices de lectura, podemos
concluir que el #3 es el factor más probable. Si ellos cambian, entonces podemos obtener más claves para
comprender por qué el tiempo de servicio es alto para este dispositivo.
De manera similar, podemos buscar en la columna de índice de lectura para desplegar el disco bajo índices
constantes de lectura.
# iostat -x | sort -nrk6
sdj
0.00
0.00
1.86
sdah 0.00
0.00
1.66
sdd
0.00
0.00
1.26
sdj
6.40
28.22
0.03
sdah 5.47
28.17
0.02
sdd
5.75
28.48
0.01
0.61 56.78
12.80 28.39 ...
0.52 50.54
10.94 25.27 ...
0.48 38.18
11.49 19.09 ...
10.69
9.99
2.46
10.69 10.00
2.18
3.57
3.52
0.61
... and so on ...
La información lo ayuda a localizar un disco que está “activo”—es decir, sujeto a muchas lecturas o escrituras.
Si el disco se encuentra verdaderamente activo, usted debería identificar la razón de ello; tal vez un filesystem
definido en el disco está sujeto a demasiadas lecturas. Si ese es el caso, usted debería considerar el hecho
de descartar filesystem de los discos para distribuir la carga, minimizando así la posibilidad de que un disco
específico esté activo.
sar
De los debates anteriores, surge un thread común: Obtener métricas en tiempo real no es lo más importante;
la tendencia histórica también es importante.
Además, tenga en cuenta esta situación: ¿cuántas veces alguien plantea un problema de desempeño y
cuando usted comienza a investigar, todo vuelve a la normalidad? Los problemas de desempeño que han
ocurrido en el pasado son difíciles de diagnosticar si carece de datos específicos. Finalmente, usted decidirá
examinar el desempeño de los datos en los últimos días para obtener algunos parámetros o para realizar
algunos ajustes.
El comando sar cumple con ese objetivo. sar significa System Activity Recorder, y registra las métricas de los
componentes clave del sistema Linux—CPU, Memoria, Discos, Redes, etc.—en un lugar especial: directory
/var/log/sa. Los datos se graban cada día en un archivo denominado sa<nn> en donde <nn> es el día de dos
dígitos del mes. Por ejemplo, el archivo sa27 contiene los datos para el día 27 de ese mes. Estos datos
pueden ser consultados por el comando sar.
La manera más sencilla de utilizar sar es sin ningún argumento ni opción. Por ejemplo:
# sar
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
12:00:01 AM
12:10:01 AM
12:20:01 AM
12:30:01 AM
12:40:01 AM
... and so on
CPU
all
all
all
all
...
%user
14.99
14.97
15.80
10.26
%nice
0.00
0.00
0.00
0.00
%system
1.27
1.20
1.39
1.25
12/27/2008
%iowait
2.85
2.70
3.00
3.55
%idle
80.89
81.13
79.81
84.93
El output muestra las métricas relacionadas con la CPU recogidas en intervalos de 10 minutos. Las columnas
significan:
CPU
Identificador de CPU; “all” significa todas las CPU
%user
Porcentaje de CPU utilizado para los procesos de usuarios. Los procesos de Oracle se
presentan en esta categoría.
%nice
El % de utilización de CPU mientras se ejecuta una prioridad nice
%system El % de CPU que ejecuta los procesos del sistema
%iowait
El % de CPU en espera para I/O
%idle
El % de CPU inactiva en espera de trabajos
En el output anterior, podemos ver que el sistema se encuentra bien balanceado; en realidad, por debajo del
nivel infrautilizado (como se muestra en el alto grado de inactividad). Profundizando más el output podemos
ver lo siguiente:
... continued from
03:00:01 AM CPU
03:10:01 AM all
03:20:01 AM all
03:30:01 AM all
03:40:01 AM all
... and so on ...
above ...
%user
%nice
44.99
0.00
44.97
0.00
45.80
0.00
40.26
0.00
%system
1.27
1.20
1.39
1.25
%iowait
2.85
2.70
3.00
3.55
%idle
40.89
41.13
39.81
44.93
Esto nos muestra otra historia: el sistema fue cargado por algunos procesos de usuarios entre las 3:00 y las
3:40. Tal vez se estaba ejecutando una consulta extensa; o tal vez se estaba ejecutando un trabajo RMAN,
consumiendo así toda esa CPU. Aquí es en donde el comando sar es útil –despliega los datos registrados que
muestran información de un momento específico, no del momento actual. Esto es exactamente lo que usted
necesita para cumplir con los tres objetivos detallados al comienzo de esta sección: obtener datos históricos,
encontrar patrones de uso y comprender las tendencias.
Si usted desea ver datos sar de un día específico, simplemente abra sar con ese nombre de archivo,
utilizando la opción -f como se muestra abajo (para abrir los datos del día 26)
# sar -f /var/log/sa/sa26
También se pueden desplegar datos en tiempo real, similar a vmstat o mpstat. Para obtener los datos cada 5
segundos, durante 10 veces, utilice:
# sar 5 10
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
01:39:16
01:39:21
01:39:26
01:39:31
01:39:36
… and so
PM
CPU
%user
PM
all
20.32
PM
all
23.28
PM
all
29.45
PM
all
16.32
on 10 times …
%nice
0.00
0.00
0.00
0.00
12/27/2008
%system
0.18
0.20
0.27
0.20
%iowait
1.00
0.45
1.45
1.55
%idle
78.50
76.08
68.83
81.93
¿Notó el valor “all” debajo el título CPU? Esto significa que las estadísticas fueron cargadas para todas las
CPU. Para un sistema de procesador único, esto está bien; pero en sistemas con múltiples procesadores
usted desea obtener las estadísticas tanto para cada CPU individual, como para el conjunto. La opción -P ALL
cumple con esto.
#sar -P ALL 2 2
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
01:45:12
01:45:14
01:45:14
01:45:14
01:45:14
01:45:14
01:45:14
01:45:14
01:45:14
PM
PM
PM
PM
PM
PM
PM
PM
PM
CPU
all
0
1
2
3
4
5
6
%user
22.31
8.00
99.00
6.03
3.50
4.50
54.50
2.96
%nice
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
%system
10.19
24.00
1.00
18.59
8.50
14.00
6.00
7.39
12/27/2008
%iowait
0.69
0.00
0.00
0.50
0.00
0.00
0.00
2.96
%idle
66.81
68.00
0.00
74.87
88.00
81.50
39.50
86.70
01:45:14 PM
7
0.50
0.00
2.00
2.00
95.50
01:45:14
01:45:16
01:45:16
01:45:16
01:45:16
01:45:16
PM
PM
PM
PM
PM
PM
CPU
all
0
1
2
3
%user
18.98
1.00
37.00
13.50
0.00
%nice
0.00
0.00
0.00
0.00
0.00
%system
7.05
31.00
5.50
19.00
0.00
%iowait
0.19
0.00
0.00
0.00
0.00
%idle
73.78
68.00
57.50
67.50
100.00
01:45:16
01:45:16
01:45:16
01:45:16
PM
PM
PM
PM
4
5
6
7
0.00
99.00
0.50
0.00
0.00
0.00
0.00
0.00
0.50
1.00
0.00
0.00
0.00
0.00
0.00
1.49
99.50
0.00
99.50
98.51
CPU
all
0
1
2
3
4
5
6
7
%user
20.64
4.50
68.00
9.77
1.75
2.25
76.81
1.74
0.25
%nice
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
%system
8.62
27.50
3.25
18.80
4.25
7.25
3.49
3.73
1.00
%iowait
0.44
0.00
0.00
0.25
0.00
0.00
0.00
1.49
1.75
%idle
70.30
68.00
28.75
71.18
94.00
90.50
19.70
93.03
97.01
Average:
Average:
Average:
Average:
Average:
Average:
Average:
Average:
Average:
Average:
Esto muestra el identificador de CPU (comenzando con 0) y las estadísticas para cada uno. Al final del output
usted verá el promedio de ejecuciones de cada CPU.
El comando sar no solo es para estadísticas relacionadas con la CPU. También es útil obtener las estadísticas
relacionadas con la memoria. La opción -r muestra la utilización de memoria extensiva.
# sar -r
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
12:00:01
12:10:01
12:20:01
12:30:01
12:40:01
12:50:01
AM kbmemfree kbmemused
AM
712264 32178920
AM
659088 32232096
AM
651416 32239768
AM
651840 32239344
AM
700696 32190488
12:00:01
12:10:01
12:20:01
12:30:01
12:40:01
12:50:01
AM
AM
AM
AM
AM
AM
kbswpfree kbswpused
16681300
95908
16681300
95908
16681300
95908
16681300
95908
16681300
95908
12/27/2008
%memused kbbuffers
97.83
2923884
98.00
2923884
98.02
2923920
98.02
2923920
97.87
2923920
%swpused
0.57
0.57
0.57
0.57
0.57
kbswpcad
380
380
380
380
380
Veamos el significado de cada columna:
kbmemfree
Memoria libre disponible en KB en ese momento
kbcached
25430452
25430968
25431448
25430416
25430416
...
...
...
...
...
...
kbmemused
Memoria utilizada en KB en ese momento
%memused
% de memoria utilizada
kbbuffers
% de memoria utilizado como buffers
kbcached
% de memoria utilizado como caché
kbswpfree
Espacio de swap libre en KB en ese momento
kbswpused
Espacio de swap utilizado en KB en ese momento
%swpused
% de swap utilizado en ese momento
kbswpcad
Swap en caché en KB en ese momento
Al final del output, usted verá la cifra promedio para el período.
También puede obtener las estadísticas específicas relacionadas con la memoria. La opción -B muestra la
actividad relacionada con la paginación.
# sar -B
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
12:00:01 AM pgpgin/s pgpgout/s
12:10:01 AM
134.43
256.63
12:20:01 AM
122.05
181.48
12:30:01 AM
129.05
253.53
... and so on ...
fault/s
8716.33
8652.17
8347.93
12/27/2008
majflt/s
0.00
0.00
0.00
La columna muestra las métricas en ese momento, no las actuales.
pgpgin/s
Cantidad de páginas en la memoria desde el disco, por segundo
pgpgout/s
Cantidad de páginas fuera del disco, desde la memoria, por segundo
fault/s
Fallos de página por segundos
majflt/s
Principales fallos de página por segundo
Para obtener un output similar para la actividad relacionada con el swapping, usted puede utilizar la opción W.
# sar -W
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
12/27/2008
12:00:01 AM pswpin/s pswpout/s
12:10:01 AM
0.00
0.00
12:20:01 AM
0.00
0.00
12:30:01 AM
0.00
0.00
12:40:01 AM
0.00
0.00
... and so on ...
Las columnas probablemente se explican por si mismas; pero aquí se detalla la descripción de cada una:
pswpin/s
Páginas de memoria que vuelven a intercambiarse en la memoria desde el disco, por
segundo
pswpout/s Páginas de la memoria intercambiadas al disco desde la memoria, por segundo
Si usted observa que el nivel de swapping es demasiado elevado, quizás podría estar quedándose sin
memoria. No se trata de una conclusión anticipada, sino de una posibilidad.
Para obtener las estadísticas de los dispositivos de disco, utilice la opción -d:
# sar -d
Linux 2.6.9-55.0.9.ELlargesmp (prolin3)
12:00:01 AM
DEV
12:10:01 AM
dev1-0
12:10:01 AM
dev1-1
12:10:01 AM
dev1-2
12:10:01 AM
dev1-3
12:10:01 AM
dev1-4
... and so on ...
Average:
dev8-48
Average:
dev8-64
Average:
dev8-80
Average:
dev8-96
Average:
dev8-112
12/27/2008
tps
0.00
5.12
3.04
0.18
1.67
rd_sec/s
0.00
0.00
42.47
1.68
18.94
wr_sec/s
0.00
219.61
22.20
1.41
15.19
4.48
0.00
2.00
0.00
2.22
100.64
0.00
47.82
0.00
49.22
22.15
0.00
5.37
0.00
12.08
Aquí está la descripción de las columnas. Nuevamente, ellas muestran las métricas en ese momento.
tps
Transferencias por segundo. El término transferencias se refiere a las operaciones I/O.
Nota: es solamente la cantidad de operaciones; cada operación puede ser extensa o
pequeña. Por lo tanto, esto, por sí mismo, no es la historia completa.
rd_sec/s Cantidad de sectores leídos desde el disco por Segundo
wr_sec/s Cantidad de sectores escritos en el disco por Segundo
Para obtener el historial de estadísticas de red, usted puede utilizar la opción -n:
# sar -n DEV | more
Linux 2.6.9-42.0.3.ELlargesmp (prolin3)
12:00:01
rxmcst/s
12:10:01
0.00
12:10:01
0.99
12:10:01
0.00
12:10:01
0.00
12:10:01
0.00
12:10:01
0.99
12:10:01
0.00
AM
IFACE rxpck/s txpck/s
12/27/2008
rxbyt/s
txbyt/s rxcmp/s txcmp/s
AM
lo
4.54
4.54
782.08
782.08
0.00
0.00
AM
eth0
2.70
0.00
243.24
0.00
0.00
0.00
AM
eth1
0.00
0.00
0.00
0.00
0.00
0.00
AM
eth2
0.00
0.00
0.00
0.00
0.00
0.00
AM
eth3
0.00
0.00
0.00
0.00
0.00
0.00
AM
eth4
143.79
141.14 73032.72 38273.59
0.00
0.00
AM
eth5
0.00
0.00
0.00
0.00
0.00
0.00
12:10:01
0.00
12:10:01
0.00
12:10:01
1.98
… and so
Average:
1.98
Average:
0.00
Average:
0.00
Average:
0.00
AM
eth6
0.00
0.00
0.00
0.00
0.00
0.00
AM
eth7
0.00
0.00
0.00
0.00
0.00
0.00
AM
bond0
146.49
141.14 73275.96 38273.59
0.00
0.00
bond0
128.73
121.81 85529.98 27838.44
0.00
0.00
eth8
0.00
0.00
0.00
0.00
0.00
eth9
3.52
6.74
251.63 10179.83
0.00
0.00
sit0
0.00
0.00
0.00
0.00
on …
0.00
0.00
0.00
En resumen, usted tiene estas opciones para el comando sar a fin de obtener las métricas para los
componentes:
Utilice esta opción …
… para obtener estadísticas sobre:
-P CPU(s) Específica(s)
-d Discos
-r Memoria
-B Paginación
-W Intercambio
-n Red
¿Qué sucede si usted desea tener todas las estadísticas disponibles en un solo output? En lugar de invocar
sar con todas estas opciones, usted puede utilizar la opción -A que muestra todas las estadísticas
almacenadas en los archivos sar.
Conclusión
Para resumir, al utilizar estos grupos de comandos limitados usted puede manejar la mayoría de las tareas
que intervienen en la administración de recursos en un entorno Linux. Sugiero que los practique en su entorno
a fin de familiarizarse con estos comandos y con las opciones aquí descriptas.
En las próximas entregas, aprenderá cómo monitorear y administrar la red. También aprenderá varios
comandos que lo ayudarán a administrar un entorno Linux: para descubrir quién se ha registrado para
establecer procesos shell profile, realizar backups utilizando cpio y tar, entre otras cosas.
Guía para Maestría Avanzada en Comandos Linux, Parte 4:
Administración del Entorno Linux
Por Arup Nanda
Publicado en mayo de 2009
En esta serie, sepa cómo administrar el entorno Linux de manera efectiva a través de estos comandos
ampliamente utilizados.
ifconfig
El comando ifconfig muestra los detalles de la/s interfaz/interfaces de red definidas en el sistema. La opción
más común es -a , lo cual permite mostrar todas las interfaces.
# ifconfig -a
El nombre usual de la interfaz de red Ethernet primaria es eth0. Para encontrar los detalles de una interfaz
específica, por ej., eth0, puede utilizar:
# ifconfig eth0
A continuación se muestra el output con su respectiva explicación:
Éstas son algunas partes claves del output:







Link encap: corresponde al tipo de medio de hardware físico soportado por esta interfaz (Ethernet,
en este caso)
HWaddr: es el identificador exclusivo de la tarjeta NIC. Cada tarjeta NIC tiene un identificador
exclusivo asignado por el fabricante, denominado MAC o dirección MAC. La dirección de IP se
adjunta al MAC del servidor. Si esta dirección de IP cambia, o esta tarjeta se mueve desde este
servidor a otro, el MAC continúa siendo el mismo.
Mask: corresponde a la máscara de red
inet addr: es la dirección de IP que se adjunta a la interfaz
RX packets: se refiere a la cantidad de paquetes recibidos por esta interfaz
TX packets: se refiere a la cantidad de paquetes enviados
errors: es la cantidad de errores de envío y recepción
El comando no se utiliza solamente para controlar los parámetros; también se utiliza para configurar y
administrar la interfaz. A continuación presentamos un breve listado de los parámetros y opciones de este
comando:
up/down – activa o desactiva una interfaz específica. Usted puede utilizar el parámetro down para
desconectar una interfaz (o desactivarla):
# ifconfig eth0 down
De manera similar, para conectarla (o activarla), usted debería utilizar:
# ifconfig eth0 up
media – establece el tipo de medio Ethernet como 10baseT, 10 Base 2, etc. Los valores comunes para el
parámetro de medios son 10base2, 10baseT, y AUI. Si usted desea que Linux detecte el medio
automáticamente, puede especificar “auto”, como se muestra a continuación:
# ifconfig eth0 media auto
add – establece una dirección de IP específica para la interfaz. Para determinar una dirección de IP
192.168.1.101 para la interfaz eth0, usted debería emitir lo siguiente:
# ifconfig eth0 add
192.168.1.101
netmask – determina el parámetro de máscara de red de la interfaz. A continuación se presenta un ejemplo
en dónde puede establecer la máscara de red de la interfaz eth0 en 255.255.255.0
# ifconfig eth0 netmask
255.255.255.0
En un entorno Oracle Real Application Clusters usted debe establecer la máscara de red en cierto modo,
utilizando este comando.
En algunas configuraciones avanzadas, usted puede cambiar la dirección de MAC asignada a la interfaz de
red. El parámetro hw lo hace posible. El formato general es:
ifconfig <Interface> hw <TypeOfInterface>
<MAC>
<TypeOfInterface> muestra el tipo de interfaz, por ej., ether, para Ethernet. Aquí se muestra cómo la dirección
MAC ha cambiado para eth0 a 12.34.56.78.90.12 (Nota: la dirección MAC que aquí se muestra es ficticia. En
caso de ser igual a otra MAC real, es pura coincidencia):
# ifconfig eth0 hw ether
12.34.56.78.90.12
Esto es útil cuando usted agrega una nueva tarjeta (con una nueva dirección MAC) pero no desea cambiar la
configuración relacionada con Linux como por ejemplo las interfaces de red.
Para Usuarios de Oracle
El comando, junto con nestat descripto anteriormente, es uno de los comandos más frecuentemente utilizados
para administrar Oracle RAC. El desempeño de Oracle RAC depende en gran medida de la interconexión
utilizada entre los nodos del cluster. Si la interconexión se satura (es decir, que no puede soportar más tráfico
adicional) o falla, usted podrá observar una disminución de desempeño. Lo mejor en este caso es observar el
output ifconfig para detectar las fallas. Este es un ejemplo típico:
# ifconfig eth9
eth9
Link encap:Ethernet
HWaddr 00:1C:23:CE:6F:82
inet addr:10.14.104.31
Bcast:10.14.104.255
Mask:255.255.255.0
inet6 addr: fe80::21c:23ff:fece:6f82/64 Scope:Link
UP BROADCAST RUNNING MULTICAST
MTU:1500 Metric:1
RX packets:1204285416 errors:0
dropped:560923
overruns:0 frame:0
TX packets:587443664 errors:0
dropped:623409
overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:1670104239570 (1.5 TiB) TX bytes:42726010594 (39.7 GiB)
Interrupt:169 Memory:f8000000-f8012100
Observe el texto resaltado en rojo. El conteo arrojado es extremadamente elevado; la cantidad ideal debería
ser 0 o cercana a 0. Una cantidad mayor a medio millón implicaría una interconexión defectuosa que rechaza
los paquetes, provocando que la interconexión los reenvíe—lo cual sería clave para el diagnóstico de
problemas.
netstat
El estado input y output a través de una interfaz de red se evalúa por medio del comando netstat. Este
comando puede brindar información completa sobre el desempeño de la interfaz de red, incluso por debajo del
nivel de socket. Aquí vemos un ejemplo:
# netstat
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address Foreign Address
tcp
0
0 prolin1:31027 prolin1:5500
State
TIME_WAIT
tcp
tcp
tcp
tcp
4
0
0
0
0
0
0
0
prolin1l:1521
prolin1l:1522
prolin1l:3938
prolin1l:1521
applin1:40205
prolin1:39957
prolin1:31017
prolin1:21545
ESTABLISHED
ESTABLISHED
TIME_WAIT
ESTABLISHED
… and so on …
El output de arriba muestra todos los sockets abiertos. En términos más simples, un socket es similar a una
conexión entre dos procesos. [Por favor tenga en cuanta que, estrictamente hablando, los conceptos “sockets”
y “conexiones” son técnicamente diferentes. Un socket podría existir sin una conexión. De todas maneras, el
debate entre sockets y conexiones escapa del alcance de este artículo. Por eso simplemente me limité a
presentar el concepto de una manera fácil de comprender]. Naturalmente, una conexión debe tener un origen
y un destino, denominados dirección local y remota. Los puntos de destino podrían estar en el mismo servidor
o en servidores distintos.
En muchos casos, los programas se conectan al mismo servidor. Por ejemplo, si dos procesos se comunican
entre ellos, la dirección local y remota será la misma, como puede observar en la primera línea –tanto la
dirección local como la remota corresponden al servidor “prolin1”. No obstante, los procesos se comunican a
través de un puerto, que es diferente. El puerto se muestra luego del nombre de host, después de los dos
puntos “:”. El programa del usuario envía los datos que deben remitirse a través del socket a una cola y el
receptor los lee desde la cola de destino remoto. Éstas son las columnas del output:
1.
2.
3.
4.
5.
6.
la columna del extremo izquierdo denominada “ Proto” muestra el tipo de conexión – tcp en este
caso.
La columna Recv-Q muestra los bytes de datos en cola a ser enviados al programa del usuario que
estableció la conexión. Este valor debería ser un valor cercano a 0, preferentemente. En los
servidores ocupados este valor será mayor a 0 pero no debería ser demasiado alto. Una cantidad
mayor no podría significar mucho, a menos que observe una cantidad elevada en la columna SendQ, descripta a continuación.
La columna Send-Q denota los bytes en cola a ser enviados al programa remoto, es decir, el
programa remoto aún no ha confirmado su recepción. Esta cantidad debería ser cercana a 0. Una
cantidad mayor podría indicar un cuello de botella en la red.
Local Address se refiere al origen de la conexión y el número de puerto del programa.
Foreign Address hace referencia al host de destino y el número de puerto. En la primera línea, tanto
el origen como el destino corresponden al mismo host: prolin1. La conexión se encuentra
simplemente en espera. La segunda línea muestra una conexión establecida entre el puerto 1521 de
proiln1 hasta el puerto 40205 del host applin1. Lo más probable es que una conexión de Oracle
venga del applin1 cliente hasta el servidor prolin1. El listener de Oracle en prolin1 se ejecuta en el
puerto 1521; de manera que el puerto de origen es 1521. En esta conexión, el servidor envía los
datos solicitados al cliente.
La columna State muestra el estado de la conexión. Aquí vemos algunos valores comunes.
7.
o ESTABLISHED – implica que la conexión ha sido establecida. No significa que los datos
fluyen entre los puntos de destino; simplemente que se ha establecido una comunicación
entre ellos.
o CLOSED – la conexión se ha cerrado, es decir, no está siendo utilizada.
o TIME_WAIT – la conexión se está cerrando pero aún hay paquetes pendientes en la red.
o CLOSE_WAIT – el destino remoto ha sido cerrado y se ha solicitado el cierre de conexión.
Pues bien, a partir de las direcciones locales (local) y externas (foreign), y especialmente a partir de los
números de puertos, probablemente podamos deducir que las conexiones son conexiones relacionadas a
Oracle, pero ¿no sería mejor estar seguros? Por supuesto. La opción -p también muestra la información del
proceso:
# netstat -p
Proto Recv-Q Send-Q Local Address Foreign Address State
name
tcp
0
0
prolin1:1521 prolin1:33303 ESTABLISHED
1327/oraclePROPRD1
PID/Program
tcp
0
0
prolin1:1521
13827/oraclePROPRD1
tcp
0
0
prolin1:1521
tcp
0
0
prolin1:1521
15251/oracle+ASM
tcp
0
0
prolin1:1521
applin1:51324 ESTABLISHED
prolin1:33298 ESTABLISHED 32695/tnslsnr
prolin1:32544 ESTABLISHED
prolin1:33331 ESTABLISHED 32695/tnslsnr
Esto muestra claramente el IP del proceso y el nombre del proceso en la última columna, la cual confirma que
corresponden a procesos del servidor de Oracle, al proceso listener, y a los procesos del servidor ASM.
El comando netstat puede presentar varias opciones y parámetros. A continuación se detallan los más
importantes:
Para ver las estadísticas de red de las distintas interfaces, utilice la opción -i.
# netstat -i
Kernel Interface table
Iface MTU Met RX-OK
RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR
Flg
eth0 1500 0 6860659
0
0
0
2055833
0
0
0
BMRU
eth8 1500 0 2345
0
0
0
833
0
0
0
BMRU
lo
6436 0 14449079
0
0
0
14449079
0
0
0
LRU
Esto muestra las distintas interfaces presentes en el servidor (eth0, eth8, etc.) y las métricas relacionadas con
la interfaz.




RX-OK muestra la cantidad de paquetes que son exitosamente enviados (para esta interfaz)
RX-ERR muestra la cantidad de errores
RX-DRP muestra los paquetes rechazados que debieron ser reenviados (ya sea con éxito o no)
RX-OVR muestra un exceso de paquetes
El próximo grupo de columnas (TX-OK, TX-ERR, etc.) muestra las stats (estadísticas) correspondientes a los
datos enviados.
La columna Flg expresa un valor compuesto de la propiedad de la interfaz. Cada letra indica una propiedad
específica presente. A continuación se detalla el significado de las letras.
B – Broadcasting (Difusión)
M –Multicast (Multidifusión)
R – Running (En ejecución)
U – Up (Activado)
O – ARP Off (ARP desactivado)
P – Point to Point Connection (Conexión Punto a Punto)
L – Loopback (Circuito cerrado)
m – Master
s - Slave
Usted pude utilizar la opción --interface (nota: hay dos guiones, no uno) para desplegar una interfaz
específica.
# netstat --interface=eth0
Kernel Interface table
Iface MTU Met RX-OK
RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR
Flg
eth0 1500 0 277903459
0
0
0
170897632 0
0
0
BMsRU
De más está decir que, el output es amplio y un poco difícil de captar de un solo intento. Si usted está
realizando una comparación entre interfaces, sería lógico tener un output tabular. Si desea examinar los
valores en un formato más legible, utilice la opción -e para producir un output extendido:
# netstat -i -e
Kernel Interface table
eth0
Link encap:Ethernet
HWaddr 00:13:72:CC:EB:00
inet addr:10.14.106.0
Bcast:10.14.107.255
Mask:255.255.252.0
inet6 addr: fe80::213:72ff:fecc:eb00/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:6861068 errors:0 dropped:0 overruns:0 frame:0
TX packets:2055956 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:3574788558 (3.3 GiB) TX bytes:401608995 (383.0 MiB)
Interrupt:169
¿El output le resulta conocido? Debería ser así ya que es el mismo que el output de ifconfig.
Si prefiere que el output despliegue las direcciones de IP en lugar de los nombres del host, utilice la opción -n.
La opción -s muestra el resumen de estadísticas de cada protocolo, en vez de mostrar los detalles de cada
conexión. Esto puede combinarse con el flag específico del protocolo, Por ejemplo, -u muestra las estadísticas
relacionadas con el protocolo UDP.
# netstat -s -u
Udp:
12764104 packets received
600849 packets to unknown port received.
0 packet receive errors
13455783 packets sent
Del mismo modo, para ver las stats de tcp, utilice -t y para raw, -r.
Una de las opciones realmente útiles es desplegar la tabla de ruta, utilizando la opción -r.
# netstat -r
Kernel IP routing table
Destination
Gateway
10.20.191.0
*
172.22.13.0
*
169.254.0.0
*
default
10.20.191.1
Genmask
255.255.255.128
255.255.255.0
255.255.0.0
0.0.0.0
Flags
U
U
U
UG
MSS Window irtt Iface
0
0
0 bond0
0
0
0 eth9
0
0
0 eth9
0
0
0 bond0
La segunda columna del output netstat – Gateway–muestra el gateway de asignación de ruta. Si no se utiliza
ningún gateway, aparece un asterisco. La tercera columna– Genmask–muestra la “generalidad” del
enrutamiento, es decir, la máscara de red para esta ruta. Al dar una dirección de IP para encontrar una ruta
adecuada, el kernel sigue el proceso de cada una de las entradas de enrutamiento, tomando el nivel de bits
AND de la dirección y la máscara de red antes de compararlo con el destino de ruta.
La cuarta columna, denominada Flags, despliega las siguientes etiquetas que describen la ruta:





G significa que la ruta utiliza un gateway.
U implica que la interfaz a ser utilizada se encuentra activa (disponible).
H implica que solo puede alcanzarse un único host a través de la ruta. Por ejemplo, el caso de la
entrada de loopback (circuito cerrado) 127.0.0.1.
D significa que esta ruta ha sido dinámicamente creada.
! significa que la ruta ha sido rechazada y se descartarán los datos.
La siguientes tres columnas muestran los valores MSS, Window e irtt que se aplicarán a las conexiones TCP
establecidas por medio de esta ruta.



MSS representa la sigla Maximum Segment Size (Tamaño de Segmento Máximo) –es el tamaño del
datagrama más amplio para realizar la transmisión a través de esta ruta.
Window se refiere a la cantidad máxima de datos que el sistema aceptará en modo single burst
desde un host remoto y para esta ruta.
irtt representa la sigla de Initial Round Trip Time (el Valor Inicial del Temporizador TCP). Es un poco
difícil de explicar, pero lo haré por separado.
El protocolo TCP posee un control de fiabilidad incorporado. Si un paquete de datos falla durante la
transmisión, éste es retransmitido. El protocolo lleva un registro de cuánto tiempo tardan los datos en llegar a
destino y en confirmarse su recepción. Si la confirmación no llega dentro de ese plazo de tiempo, el paquete
es retransmitido. La cantidad de tiempo que el protocolo debe esperar antes de retransmitir los datos se
establece solo una vez para la interfaz (la cual puede cambiarse) y ese valor es conocido como initial round
trip time. Un valor de 0 implica que el valor por defecto es utilizado.
Finalmente, el último campo despliega la interfaz de red que utilizará esta ruta.
nslookup
Cada host accesible en una red debería tener una dirección de IP que le permita identificarse exclusivamente
en la red. En Internet, que es una red extensa, las direcciones de IP permiten que las conexiones lleguen a los
servidores que ejecutan sitios Web, por ej., www.oracle.com. Por lo tanto, cuando un host (como un cliente)
desea conectarse a otro (como un servidor de base de datos) utilizando su nombre y no su dirección de IP
¿cómo el browser cliente sabe a qué dirección conectarse?
El mecanismo de traspaso del nombre de host a las direcciones de IP es conocido como resolución de
nombre. En el nivel más rudimentario, el host tiene un archivo especial denominado hosts, que almacena la
Dirección de IP – Hostname. Este es un archivo de muestra:
# cat /etc/hosts
# Do not remove the following line, or various programs
# that require network functionality will fail.
127.0.0.1
localhost.localdomain
localhost
192.168.1.101
prolin1.proligence.com
prolin1
192.168.1.102
prolin2.proligence.com
prolin2
Esto muestra que el nombre del host prolin1.proligence.com se traduce a 192.168.1.101. La entrada especial
con la dirección de IP 127.0.0.1 se denomina entrada loopback, la cual vuelve al servidor mismo por medio de
una interfaz de red especial denominada lo (que se menciona anteriormente en los comandos ifconfig y
netstat).
Ahora bien, de todas formas, usted posiblemente no puede colocar todas las direcciones de IP del mundo en
este archivo. Por lo que debería haber otro mecanismo que establezca la resolución del nombre. Un servidor
con un propósito especial denominado nameserver realiza esa función. Es como un directorio que provee su
compañía telefónica; no su directorio personal. Pueden existir varios nameservers disponibles dentro y fuera
de la red privada. El host contacta a uno de estos nameservers primero, obtiene la dirección de IP del host de
destino que desea contactar y luego intenta conectarse a la dirección de IP.
¿Y cómo el host sabe cuáles son estos nameservers? Busca en un archivo especial llamado /etc/resolv.conf
para obtener esa información. Aquí vemos un archivo resolv de ejemplo.
; generated by /sbin/dhclient-script
search proligence.com
nameserver 10.14.1.58
nameserver 10.14.1.59
nameserver 10.20.223.108
¿Pero cómo podemos estar seguros de que la resolución del nombre está funcionando perfectamente para un
nombre de host específico? En otras palabras, usted quiere asegurarse de que cuando el sistema de Linux
intente contactarse a un host denominado oracle.com, pueda encontrar la dirección de IP en el nameserver. El
comando nslookup es útil para eso. Vea a continuación cómo utilizarlo:
# nslookup oracle.com
Server:
10.14.1.58
Address:
10.14.1.58#53
** server can't
find
oracle-site.com: NXDOMAIN
Analicemos el output. El output del Server (Servidor) es la dirección del nameserver. El nombre oracle.com
establece la dirección de IP 141.146.8.66. El nombre fue definido por el nameserver próximo a la palabra
Server en el output.
Si usted escribe esta dirección de IP en un browser–http://141.146.8.66 en lugar de http://oracle.com--el
browser se dirigirá al sitio oracle.com.
Si usted cometió un error o buscó un host equivocado:
# nslookup oracle-site.com
Server:
10.14.1.58
Address:
10.14.1.58#53
** server can't find
oracle-site.com: NXDOMAIN
El mensaje es bastante claro: este host no existe.
dig
El comando nslookup ha caído en desuso. En su lugar debería utilizarse un comando nuevo y más poderoso –
dig ( domain information groper). En algunos servidores Linux más nuevos, el comando nslookup podría no
estar aún disponible.
Aquí vemos un ejemplo; para verificar la resolución del nombre del host oracle.com, debería utilizar el
siguiente comando:
# dig oracle.com
; <<>> DiG 9.2.4 <<>> oracle.com
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 62512
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 8, ADDITIONAL: 8
;; QUESTION SECTION:
;oracle.com.
IN
A
;; ANSWER SECTION:
oracle.com.
300
IN
A
141.146.8.66
;; AUTHORITY SECTION:
oracle.com.
oracle.com.
oracle.com.
oracle.com.
oracle.com.
oracle.com.
oracle.com.
oracle.com.
3230
3230
3230
3230
3230
3230
3230
3230
IN
IN
IN
IN
IN
IN
IN
IN
NS
NS
NS
NS
NS
NS
NS
NS
ns1.oracle.com.
ns4.oracle.com.
u-ns1.oracle.com.
u-ns2.oracle.com.
u-ns3.oracle.com.
u-ns4.oracle.com.
u-ns5.oracle.com.
u-ns6.oracle.com.
;; ADDITIONAL SECTION:
ns1.oracle.com.
ns4.oracle.com.
u-ns1.oracle.com.
u-ns2.oracle.com.
u-ns3.oracle.com.
u-ns4.oracle.com.
u-ns5.oracle.com.
u-ns6.oracle.com.
124934
124934
46043
46043
46043
46043
46043
46043
IN
IN
IN
IN
IN
IN
IN
IN
A
A
A
A
A
A
A
A
148.87.1.20
148.87.112.100
204.74.108.1
204.74.109.1
199.7.68.1
199.7.69.1
204.74.114.1
204.74.115.1
;;
;;
;;
;;
Query time: 97 msec
SERVER: 10.14.1.58#53(10.14.1.58)
WHEN: Mon Dec 29 22:05:56 2008
MSG SIZE rcvd: 328
Desde el output mammoth, se destacan varias cosas. Muestra que el comando ha enviado una consulta al
nameserver y el host obtuvo una respuesta del nameserver. La resolución del nombre también ha sido
efectuada en otros nameservers como ns1.oracle.com. Esto demuestra que la consulta tardó 97 milisegundos
en ejecutarse.
Si el tamaño del output no es el adecuado, usted puede utilizar la opción +short para eliminar las palabras
redundantes del output:
# dig +short oracle.com
141.146.8.66
También puede utilizar la dirección de IP para realizar una búsqueda inversa del nombre de host a partir de la
dirección de IP. Para esto se utiliza la opción -x.
# dig -x 141.146.8.66
El parámetro +domain es útil cuando usted busca un host dentro de un dominio. Por ejemplo, supongamos
que usted está buscando el host otn en el dominio oracle.com, usted puede utilizar:
# dig +short otn.oracle.com
O puede utilizar el parámetro +domain:
# dig +short +tcp +domain=oracle.com otn
www.oracle.com.
www.oraclegha.com.
141.146.8.66
Para Usuarios de Oracle
Se establece la conectividad entre el servidor de aplicaciones y el servidor de base de datos. El archivo
TNSNAMES.ORA, utilizado por SQL*Net puede parecerse a este:
prodb3 =
(description =
(address_list =
(address = (protocol = tcp)(host = prolin3)(port = 1521))
)
(connect_data =
(sid = prodb3)
)
)
El nombre de host prolin3 debería ser determinado por el servidor de aplicaciones. En cualquiera de los
casos, éste debería figurar en el archivo /etc/hosts; o el host prolin3 debería definirse en el DNS. Para
asegurarse de que la resolución del nombre funciona, y que funciona de manera correcta para dirigirse al host
adecuado, usted puede utilizar el comando dig.
Con estos dos comandos usted puede manejar la mayoría de las tareas de red en un entorno Linux. En la que
queda de esta presentación, usted aprenderá a administrar un entorno Linux de manera efectiva.
uptime
Usted ha ingresado al servidor y ha observado que algunas cosas que deberían estar funcionando, en verdad
no lo están. Tal vez algunos procesos fueron cancelados o quizás todos los procesos han sido finalizados
debido a un cierre del sistema. En lugar de hacer suposiciones, descubra si el servidor ha sido realmente
reiniciado utilizando el comando uptime. El comando muestra el plazo de tiempo durante el cual el servidor ha
estado funcionando desde su último reinicio.
# uptime
16:43:43 up 672 days, 17:46,
5.38
45 users,
load average: 4.45,
5.18,
El output muestra mucha información de utilidad. La primera columna muestra el momento real en que el
comando fue ejecutado. La segunda parte – activo 672 días, 17:46 – muestra el tiempo en que el servidor ha
estado activo. Las cifras 17:46 representan las horas y minutos. Por lo tanto, este servidor ha estado
funcionando por 672 días, 17 horas y 46 minutos hasta el momento.
El siguiente elemento – 45 usuarios – muestra la cantidad de usuarios que han iniciado sesión en el servidor
justo en ese momento.
Los últimos bits del output muestran el promedio de carga del servidor en el último minuto, y en los último 5 y
15 minutos respectivamente. El término “carga promedio” es una cifra compuesta que representa la carga del
sistema sobre la base de las métricas de I/O y CPU. Cuanto mayor es el promedio de carga, mayor la carga
en el sistema. No se basa en una escala; a diferencia de los porcentajes, no finaliza con una cantidad
determinada, como 100. Además, la carga promedio de dos sistemas no puede compararse entre sí. Dicha
cifra se utiliza para cuantificar la carga en un sistema y solo es relevante para ese único sistema. Este output
muestra que la carga promedio fue de 4,45 en el último minuto, 5,18 en los últimos 5 minutos y así
sucesivamente.
El comando no tiene ninguna opción ni acepta ningún parámetro que no sea -V, el cual muestra la versión del
comando.
# uptime -V
procps version 3.2.3
Para Usuarios de Oracle
No existe un uso específico de Oracle en torno a este comando, salvo que usted puede conocer la carga del
sistema para explicar algunos problemas de desempeño. Si observa algunos problemas de desempeño en la
base de datos, y éstos surgen debido a la elevada carga de I/O o CPU, usted inmediatamente debería
controlar las cargas promedio utilizando el comando uptime. Si observa un promedio de carga elevado, su
próximo paso será realizar un examen detallado para detectar la causa del problema. Para realizar este
análisis, usted cuenta con una gran cantidad de herramientas como mpstat, iostat y sar (descriptas en esta
presentación de la serie).
Preste atención al output que se muestra a continuación:
# uptime
21:31:04 up 330 days,
7:16,
4 users,
load average: 12.90, 1.03, 1.00
Es interesante ver cómo el promedio de carga era bastante elevado (12,90) en el último minuto y luego ha
disminuido bastante, incluso hasta niveles irrelevantes, llegando a 1,03 y 1,00 en los últimos 5 y 15 minutos
respectivamente. ¿Qué significa esto? Esto demuestra que en menos de 5 minutos, se inició algún proceso
que provocó que el promedio de carga subiera repentinamente en el último minuto. Este proceso no estaba
presente anteriormente ya que el promedio de carga era bastante bajo. Este análisis nos lleva a
concentrarnos en los procesos iniciados en los últimos minutos – acelerando así el proceso de resolución.
Lógicamente, como esto demuestra la cantidad de tiempo en que el servidor ha estado funcionando, también
explica por qué la instancia ha estado activa desde aquel momento.
who
¿Quién ha ingresado en el sistema en este momento? Esa es una simple pregunta que usted podría hacerse
especialmente si desea rastrear a algún usuario errante que está ejecutando algunos comandos que
consumen recursos.
El comando who responde esa pregunta. Observe aquí el uso más simple de este comando, sin argumentos
ni parámetros.
# who
oracle
oracle
root
root
pts/2
pts/3
pts/1
:0
Jan 8 15:57
Jan 8 15:57
Dec 26 13:42
Oct 23 15:32
(10.14.105.139)
(10.14.105.139)
(:0.0)
El comando puede presentar varias opciones. La opción -s es la opción por defecto; que produce el mismo
output que arriba.
Observando el output, usted quizás esté haciendo memoria para recordar lo que significan las columnas.
Bueno, relájese. Puede utilizar la opción -H para desplegar el encabezado:
# who -H
NAME
oracle
oracle
root
root
LINE
pts/2
pts/3
pts/1
:0
TIME
COMMENT
Jan 8 15:57 (10.14.105.139)
Jan 8 15:57 (10.14.105.139)
Dec 26 13:42 (:0.0)
Oct 23 15:32
Ahora el significado de las columnas es claro. La columna NAME muestra el nombre de usuario registrado.
LINE muestra el nombre de terminal. En Linux cada conexión se denomina como una terminal con el convenio
de denominación pts/<n> en donde <n> es un número que comienza con 1. La terminal :0 es una
denominación para la terminal X. TIME muestra la primera vez en que se registraron. Y COMMENTS muestra
la dirección de IP desde donde se registraron.
¿Pero qué sucede si usted solo quiere obtener un listado con los nombres de usuarios en lugar de ver todos
esos detalles superfluos? La opción -q logra eso. Despliega los nombres de usuarios en una sola línea,
ordenados alfabéticamente. También despliega la cantidad total de usuarios al final (45, en este caso):
# who -q
ananda ananda jsmith klome
… and so on for
# users=45
oracle oracle root root
45 names
Algunos usuarios podrían haber iniciado sesión pero no estar realizando ninguna actividad en realidad. Usted
puede controlar por cuánto tiempo han estado inactivos utilizando la opción -u, lo cual es realmente útil,
especialmente si usted es el jefe.
# who -uH
NAME
LINE
oracle
pts/2
oracle
pts/3
root
pts/1
root
:0
TIME
Jan 8
Jan 8
Dec 26
Oct 23
15:57
15:57
13:42
15:32
IDLE
.
00:26
old
?
PID
18127
18127
6451
24215
COMMENT
(10.14.105.139)
(10.14.105.139)
(:0.0)
La nueva columna IDLE muestra el tiempo de inactividad con el formato hh:mm. ¿Observa el valor “old” en
esa columna? Implica que el usuario ha estado inactivo durante más de 1 día. La columna PID muestra el ID
del proceso de su conexión shell.
Otra opción útil es -b que muestra cuando el sistema ha sido reiniciado.
# who -b
system boot
Feb 15
13:31
Muestra que el sistema ha sido reiniciado el 15 de febrero a la 1:31 p.m. ¿Recuerda el comando uptime?
También muestra la cantidad de tiempo durante el cual el sistema ha estado activo. Usted puede restar los
días que se observan en uptime para saber la fecha de reinicio. El comando -b facilita esto ya que
directamente muestra la fecha de reinicio.
Advertencia Importante: El comando who -b muestra el mes y la fecha únicamente, no el año. De modo que
si el sistema ha estado activo por más de un año, el output no reflejará el valor correcto. Por consiguiente el
comando uptime siempre es el enfoque preferido, incluso si usted tiene que hacer algunos cálculos. Aquí
vemos un ejemplo:
# uptime
21:37:49 up 675 days, 22:40,
1 user,
# who -b
system boot
Mar 7 22:58
load average: 3.35,
3.08, 2.86
Observe que la fecha de reinicio es el 7 de marzo. Eso fue en 2007 ¡no en 2008! El uptime muestra la fecha
correcta – ha estado activo durante 675 días. Si las restas no son su fuerte, puede utilizar un simple SQL para
obtener esa fecha, 675 días atrás:
SQL> select sysdate - 675
from dual;
SYSDATE-6
--------07-MAR-07
La opción -l muestra los inicios de sesión al sistema:
# who -lH
NAME
LINE
LOGIN
tty1
LOGIN
tty6
TIME
Feb 15
Feb 15
IDLE
PID COMMENT
4081 id=1
4254 id=6
13:32
13:32
Para descubrir las terminales del usuario que ya no están en uso, utilice la opción -d:
# who -dH
NAME
LINE
pts/1
pts/4
pts/3
pts/2
pts/5
TIME
Feb 15
Feb 15
Oct 10
Jan 11
Jun 29
Oct 4
Dec 30
IDLE
13:31
13:32
14:53
00:20
16:01
22:35
03:15
PID
489
2870
31869
22155
0
8371
5026
COMMENT
id=si
id=l5
id=ts/1
id=ts/4
id=/3
id=/2
id=ts/5
EXIT
term=0
term=0
term=0
term=0
term=0
term=0
term=0
exit=0
exit=0
exit=0
exit=0
exit=0
exit=0
exit=0
pts/4
Dec 30
22:35
0 id=/4
term=0 exit=0
Algunas veces el proceso init (el proceso que primero se ejecuta cuando se reinicia el sistema) inicia otros
procesos. La opción -p muestra todos esos inicios de sesión que están activos.
# who -pH
NAME
LINE
TIME
Feb 15
Feb 15
Feb 15
Feb 15
Feb 15
Oct 4
PID
4083
4090
4166
4174
4255
13754
13:32
13:32
13:32
13:32
13:32
23:14
COMMENT
id=2
id=3
id=4
id=5
id=x
id=h1
Más adelante en este documento, usted conocerá un comando – write – que permite enviar y recibir mensajes
en tiempo real. También aprenderá a desactivar la capacidad de otros para escribir en su terminal (el
comando mesg). Si desea saber qué usuarios permiten y no permiten a los demás escribir en sus terminales,
utilice la opción -T:
# who -TH
NAME
oracle
+
oracle
+
oracle
root
+
root
?
LINE
pts/2
pts/3
pts/4
pts/1
:0
TIME
Jan 11
Jan 11
Jan 11
Dec 26
Oct 23
12:08
12:08
12:08
13:42
15:32
COMMENT
(10.23.32.10)
(10.23.32.10)
(10.23.32.10)
(:0.0)
El signo + sign antes del nombre de la terminal implica que la terminal acepta los comandos de escritura de
otros; el signo “-” significa que la terminal no lo permite. El signo “?” en este campo significa que la terminal no
soporta escrituras, por ejemplo, una sesión X-window.
El nivel actual de ejecución del sistema puede obtenerse a través de la opción -r:
# who -rH
NAME
LINE
run-level 5
TIME
Feb 15
IDLE
13:31
PID COMMENT
last=S
Con la opción -a (all) puede obtenerse un listado más descriptivo. Esta opción combina las opciones -b -d -l p -r -t -T -u. De modo que estos dos comandos producen el mismo resultado:
# who -bdlprtTu
# who -a
Aquí vemos un output de muestra (con el encabezado, para que usted puede comprender mejor las
columnas):
# who -aH
NAME
LINE
TIME
Feb 15 13:31
IDLE
PID COMMENT EXIT
489 id=si
term=0
exit=0
system boot
run-level 5
Feb 15 13:31
Feb 15 13:31
last=S
Feb 15 13:32
exit=0
LOGIN
tty1
LOGIN
tty6
pts/1
exit=0
oracle
oracle
Feb
Feb
Feb
Feb
Feb
Feb
Feb
Oct
Oct
15
15
15
15
15
15
15
4
10
2870 id=l5
13:32
13:32
13:32
13:32
13:32
13:32
13:32
23:14
14:53
4081
4083
4090
4166
4174
4254
4255
13754
31869
+ pts/2
+ pts/3
pts/4
Jan 8 15:57
Jan 8 15:57
Dec 30 03:15
.
00:18
pts/3
Jun 29 16:01
+ pts/1
pts/2
Dec 26 13:42
Oct 4 22:35
old
? :0
pts/5
Oct 23 15:32
Dec 30 03:15
?
pts/4
Dec 30 22:35
id=1
id=2
id=3
id=4
id=5
id=6
id=x
id=h1
id=ts/1
term=0
term=0
18127 (10.14.105.139)
18127 (10.14.105.139)
5026 id=ts/4 term=0
exit=0
exit=0
root
exit=0
root
0 id=/3
term=0
6451 (:0.0)
8371 id=/2
term=0
24215
5026 id=ts/5
term=0
exit=0
0 id=/4
term=0
exit=0
Para ver su propio inicio de sesión, utilice la opción -m:
# who -m
oracle
pts/2
Jan
8 15:57
(10.14.105.139)
¿Observa el valor pts/2? Es el número de terminal. Usted puede encontrar su propia terminal a través del
comando tty:
# tty
/dev/pts/2
En Linux existe una estructura de comando especial para mostrar su propio registro de inicio de sesión –who
am i. Produce el mismo output como en la opción -m.
# who am i
oracle
pts/2
Jan
8 15:57
(10.14.105.139)
Los únicos argumentos permitidos son “am i" y “mom likes” (¡si, aunque no lo crea!). Ambos producen el
mismo output,
Original Instant Messenger System
Con la llegada de la mensajería instantánea o los programas de chat quedó comprobado que hemos
conquistado el desafío global de mantener un intercambio de información en tiempo real, sin olvidarnos de las
comunicaciones de voz. ¿Pero estos programas solo se encuentran en el ámbito de los llamados programas
atractivos?
El concepto de chat o mensajería instantánea ha estado disponible durante bastante tiempo en *nix. De
hecho, usted tiene un sistema IM seguro y completo incorporado en Linux. Éste le permite conversar de
manera segura con cualquier persona conectada al sistema; sin requerir conexión de internet. El chat es
activado a través de los comandos – write, mesg, wall y talk. Examinemos cada uno de ellos.
El comando write permite escribir en la terminal de un usuario. Si el usuario ha iniciado sesión en más de una
terminal, usted puede dirigirse a una dirección específica. Aquí se muestra cómo escribir el mensaje “Cuidado
con el virus” para el usuario “oracle” que inició sesión en la terminal “pts/3”:
# write oracle pts/3
Beware of the virus
ttyl
<Control-D>
#
La combinación de teclas Control-D finaliza el mensaje, devuelve el shell prompt (#) al usuario final y lo envía
a la terminal del usuario. Cuando éste se envía, el usuario “oracle” verá en la terminal pts/3 los mensajes:
Beware of the virus
ttyl
Cada línea aparecerá a medida que el remitente presione ENTER después de las líneas. Cuando el remitente
presiona Control-D, finalizando la transmisión, el receptor verá EOF en la pantalla. El mensaje se desplegará
independientemente de la actual acción del usuario. Si el usuario está editando un archivo en vi, el mensaje
aparece y el usuario puede eliminarlo al presionar Control-L. Si el usuario se encuentra en SQL*Plus prompt,
el mensaje aún aparece pero no afecta los registros del teclado del usuario.
¿Pero qué sucede si usted no quiere sufrir estas pequeñas molestias? Usted no quiere que nadie le envíe
mensajes del tipo –“descuelga el teléfono”. Usted puede hacerlo a través del comando mesg. Este comando
desactiva la capacidad de los demás para enviarle mensajes. El comando sin ningún argumento muestra la
siguiente capacidad:
# mesg
is y
Muestra que otros pueden escribirle. Para desactivarlo:
# mesg n
Ahora para confirmar:
# mesg
is n
Cuando usted intenta escribir en las terminales de los usuarios, quizás desee saber qué terminales han sido
desactivadas para que otros no puedan escribir en ellas. El comando -T (descripto anteriormente en este
documento) muestra que:
# who -TH
NAME
LINE
oracle
+ pts/2
TIME
COMMENT
Jan 11 12:08 (10.23.32.10)
oracle
oracle
root
root
+
+
?
pts/3
pts/4
pts/1
:0
Jan
Jan
Dec
Oct
11
11
26
23
12:08 (10.23.32.10)
12:08 (10.23.32.10)
13:42 (:0.0)
15:32
El signo + antes del nombre de terminal indica que ésta acepta escribir comandos de otros; el signo “-“ indica
que esto no está permitido. El signo “?” indica que la terminal no soporta escrituras en ella, por ej., una sesión
X-window.
¿Y qué ocurre cuando usted desea escribir a todos los usuarios que han iniciado sesión? En lugar de tipear
cada uno, utilice el comando wall:
# wall
hello everyone
Una vez que se envía, aparece el siguiente texto en las terminales de todos los usuarios que han iniciado
sesión:
Broadcast message from oracle
(pts/2) (Thu Jan
8 16:37:25 2009):
hello everyone
Esto es muy útil para los usuarios root. Cuando usted quiere cerrar el sistema, desmontar un sistema de
archivos, o realizar funciones administrativas similares, quizás desee que todos los usuarios cierren su sesión.
Utilice el comando para enviar un mensaje a todos.
Finalmente, el programa talk le permite conversar en tiempo real. Simplemente tipee lo siguiente
# talk oracle pts/2
Si desea conversar con algún usuario en un servidor diferente – prolin2 –puede utilizar
# talk oracle@prolin2 pts/2
Esto abre una ventana de conversación en la otra terminal y ahora usted puede conversar con esa persona en
tiempo real. ¿Es esto distinto a cualquier otro programa de conversación “profesional” que actualmente utiliza?
Probablemente no. A propósito, para que la conversación funcione correctamente, asegúrese de que el talkd
daemon esté ejecutándose, ya que éste podría estar desinstalado.
w
Si, es un comando ¡a pesar de que tenga solo una letra! El comando w es una combinación de los comandos
uptime y who ejecutados uno inmediatamente luego del otro, en ese orden. Veamos un output muy común sin
argumentos ni opciones.
# w
17:29:22 up 672 days, 18:31,
2 users,
load average: 4.52, 4.54, 4.59
USER
TTY
FROM
LOGIN@ IDLE
oracle pts/1 10.14.105.139 16:43 0.00s
JCPU PCPU WHAT
0.06s 0.01s w
oracle pts/2
as sysdba
… and so
10.14.105.139
17:26
57.00s 3.17s 3.17s sqlplus
on …
El output tiene dos partes distintas. La primera parte muestra el output del comando uptime (descripto arriba
en este documento) el cual muestra el tiempo en que el servidor ha esta activo, cuantos usuarios han iniciado
sesión y el promedio de carga en el último minuto y en los últimos 5 y 15 minutos. Las partes del output han
sido explicadas en el comando uptime. La segunda parte del output muestra el output del comando who con la
opción -H (también explicado en este documento). Nuevamente, las numerosas columnas también han sido
explicadas en el comando who.
Si usted prefiere no desplegar el encabezado, utilice la opción -h.
# w -h
oracle
pts/1
10.14.105.139
16:43
0.00s
0.02s
0.01s w -h
Esto elimina el encabezado del output. Es útil en los shell scripts en donde quiere leer y actuar en base al
output sin la carga adicional de saltear el encabezado.
La opción -s produce una versión compacta (corta) del output, eliminando el tiempo de inicio de sesión, y los
tiempos de JPCU y PCPU.
# w -s
17:30:07 up 672 days, 18:32,
2 users, load average: 5.03, 4.65, 4.63
USER
TTY
FROM
IDLE WHAT
oracle
pts/1
10.14.105.139
0.00s w -s
oracle
pts/2
10.14.105.139
1:42 sqlplus
as sysdba
Usted podría encontrar que el campo “FROM” realmente no es muy útil. Muestra la dirección de IP del mismo
servidor, ya que los registros de inicio de sesión son todos locales. Para ahorrar espacio en el output, usted
podría suprimir este campo. La opción -f desactiva la impresión del campo FROM:
# w -f
17:30:53 up 672 days, 18:33,
2 users, load average: 4.77, 4.65, 4.63
USER
TTY
LOGIN@
IDLE
JCPU
PCPU WHAT
oracle
pts/1
16:43
0.00s 0.06s
0.00s w -f
oracle
pts/2
17:26
2:28
3.17s
3.17s sqlplus
as sysdba
El comando acepta solo un parámetro: el nombre de un usuario. Por defecto muestra el proceso e inicio de
sesión de todos los usuarios. Si usted coloca el nombre de usuario, se muestra el registro de inicio de sesión
de ese usuario solamente. Por ejemplo, para mostrar solo el inicio de sesión de los usuarios root, debe emitir:
# w -h root
root pts/1
root :0
:0.0
-
26Dec08 13days 0.01s
23Oct08 ?xdm? 21:13m
La opción -h fue utilizada para ocultar el encabezado.
kill
0.01s bash
1.81s /usr/bin/gnome-session
Un proceso se está ejecutando y usted desea que el proceso finalice. ¿Qué debería hacer? El proceso se
ejecuta en un segundo plano, de modo que no necesita ir a la terminal y presionar Control-C; o, tal vez el
proceso pertenece a otro usuario (utilizando el mismo userid, como “oracle”) y usted desea que termine. El
comando kill justamente va al rescate; hace lo que su nombre sugiere – finaliza el proceso. Su uso más
común es:
# kill
<Process ID of the Linux process>
Supongamos que usted quiere finalizar un proceso denominado sqlplus emitido por el usuario oracle, usted
debe conocer su processid, o PID:
# ps -aef|grep sqlplus|grep ananda
oracle
8728 23916 0 10:36 pts/3
oracle
8768 23896 0 10:36 pts/2
00:00:00 sqlplus
00:00:00 grep sqlplus
Ahora para finalizar el PID 8728:
# kill 8728
Y así se finaliza el proceso. Por supuesto usted debe ser el mismo usuario (oracle) para finalizar un proceso
iniciado por oracle. Para finalizar procesos iniciados por otros usuarios usted debe ser un super usuario – root.
Algunas veces usted puede querer simplemente detener el proceso en vez de finalizarlo. Puedo utilizar la
opción -SIGSTOP con el comando kill.
# kill -SIGSTOP 9790
# ps -aef|grep sqlplus|grep oracle
oracle
9790 23916
0 10:41 pts/3
oracle
9885 23896 0 10:41 pts/2
00:00:00 sqlplus
as sysdba
00:00:00 grep sqlplus
Esto es útil para los trabajos que se realizan en segundo plano pero con procesos de primer plano.
Simplemente detiene el proceso y le quita el control al usuario. De modo que, si usted verifica el proceso
nuevamente luego de emitir el comando:
# ps -aef|grep sqlplus|grep oracle
oracle
9790 23916 0 10:41 pts/3
oracle
10144 23896 0 10:42 pts/2
00:00:00 sqlplus
as sysdba
00:00:00 grep sqlplus
Usted observa que el proceso aún se está ejecutando. No ha finalizado. Para finalizar este proceso, y
cualquier proceso que se resista a ser finalizado, debe enviar una nueva señal denominada SIGKILL. La señal
por defecto es SIGTERM.
# kill -SIGKILL 9790
# ps -aef|grep sqlplus|grep oracle
oracle
10092 23916 0 10:42 pts/3
oracle
10198 23896 0 10:43 pts/2
00:00:00 sqlplus
as sysdba
00:00:00 grep sqlplus
Tenga en cuenta las opciones -SIGSTOP y -SIGKILL, que envían una señal específica (detener y finalizar,
respectivamente) al proceso. Del mismo modo hay otras señales que puede utilizar. Para obtener un listado
de todas las señales disponibles, utilice la opción -l (la letra “L”, no el número “1”):
# kill -l
1) SIGHUP
5) SIGTRAP
9) SIGKILL
13) SIGPIPE
18) SIGCONT
22) SIGTTOU
26) SIGVTALRM
30) SIGPWR
36) SIGRTMIN+2
40) SIGRTMIN+6
44) SIGRTMIN+10
48) SIGRTMIN+14
52) SIGRTMAX-12
56) SIGRTMAX-8
60) SIGRTMAX-4
64) SIGRTMAX
2)
6)
10)
14)
19)
23)
27)
31)
37)
41)
45)
49)
53)
57)
61)
SIGINT
SIGABRT
SIGUSR1
SIGALRM
SIGSTOP
SIGURG
SIGPROF
SIGSYS
SIGRTMIN+3
SIGRTMIN+7
SIGRTMIN+11
SIGRTMIN+15
SIGRTMAX-11
SIGRTMAX-7
SIGRTMAX-3
3)
7)
11)
15)
20)
24)
28)
34)
38)
42)
46)
50)
54)
58)
62)
SIGQUIT
SIGBUS
SIGSEGV
SIGTERM
SIGTSTP
SIGXCPU
SIGWINCH
SIGRTMIN
SIGRTMIN+4
SIGRTMIN+8
SIGRTMIN+12
SIGRTMAX-14
SIGRTMAX-10
SIGRTMAX-6
SIGRTMAX-2
4)
8)
12)
17)
21)
25)
29)
35)
39)
43)
47)
51)
55)
59)
63)
SIGILL
SIGFPE
SIGUSR2
SIGCHLD
SIGTTIN
SIGXFSZ
SIGIO
SIGRTMIN+1
SIGRTMIN+5
SIGRTMIN+9
SIGRTMIN+13
SIGRTMAX-13
SIGRTMAX-9
SIGRTMAX-5
SIGRTMAX-1
También puede utilizar el numeral equivalente de la señal en lugar del verdadero nombre de la señal. Por
ejemplo, en lugar de kill -SIGKILL 9790, usted puede utilizar kill -9 9790.
A propósito, este es un comando interesante. Recuerde que casi todos los comandos Linux generalmente son
archivos ejecutables localizados en /bin, /sbin/, /user/bin y directorios similares. El PATH ejecutable determina
en dónde pueden encontrarse estos archivos de comando. Algunos otros comandos son en realidad
comandos “incorporados”, es decir, son parte del shell mismo. Un ejemplo de esto es el comando kill. Para
demostrarlo, observe lo siguiente:
# kill -h
-bash: kill: h: invalid signal
specification
Observe el output que arroja el bash shell. El uso es incorrecto ya que el argumento -h no era el adecuado.
Ahora utilice el siguiente:
# /bin/kill -h
usage: kill [ -s signal | -p ]
kill -l [ signal ]
[ -a ] pid ...
Esta versión del comando kill como ejecutable en el directorio /bin aceptó la opción -h adecuadamente. Ahora
usted ya conoce esta sutil diferencia entre los comandos shell incorporados y sus utilidades homónimas
(namesake) en la forma de archivos ejecutables.
¿Por qué es importante conocer la diferencia? Es importante porque la funcionalidad varía de manera
significativa entre estas dos formas. El comando kill incorporado tiene menos funcionalidad que su utilidad
equivalente. Cuando usted emite el comando kill, en verdad está invocando el comando incorporado, no la
utilidad. Para incorporar la otra funcionalidad, usted tiene que utilizar la utilidad /bin/kill.
La utilidad kill tiene muchas opciones y argumentos. El más conocido es el comando kill utilizado para finalizar
los proceso con los nombres del proceso, en lugar de PIDs. Aquí vemos un ejemplo en el que usted puede
finalizar todos los procesos con el nombre sqlplus:
# /bin/kill sqlplus
[1]
Terminated
sqlplus
[2]
[3]
[4]
[5]
[6]
[7][8]+
Terminated
Terminated
Terminated
Terminated
Terminated
Terminated
Terminated
sqlplus
sqlplus
sqlplus
sqlplus
sqlplus
sqlplus
sqlplus
Algunas veces usted quiere ver todos los IDs de los procesos que serán finalizados. La opción -p logra esto.
Imprime los PIDs que deberían finalizarse, sin realmente finalizarlos. Sirve como confirmación previa a la
acción:
# /bin/kill -p sqlplus
6798
6802
6803
6807
6808
6812
6813
6817
Algunas veces usted quiere ver todos los IDs de los procesos que serán finalizados. La opción -p logra esto.
Imprime los PIDs que deberían finalizarse, sin realmente finalizarlos. Sirve como confirmación previa a la
acción:
# man -k builtin
. [builtins]
: [builtins]
[ [builtins]
alias [builtins]
bash [builtins]
bg [builtins]
(1)
(1)
(1)
(1)
(1)
(1)
-
bash
bash
bash
bash
bash
bash
built-in
built-in
built-in
built-in
built-in
built-in
commands,
commands,
commands,
commands,
commands,
commands,
see
see
see
see
see
see
bash(1)
bash(1)
bash(1)
bash(1)
bash(1)
bash(1)
… y así …
El output muestra los PIDs de los procesos que serían finalizados. Si usted reemite el comando sin la opción p, se finalizarán todos esos procesos.
A esta altura usted quizás desee saber cuáles son los otros comandos “incorporados” en el shell, en lugar de
las utilidades.
# /bin/kill perl rman perl dbca
dbua java
Algunas entradas parecen conocidas – alias, bg, entre otras. Algunas se encuentran meramente incorporadas,
por ej., alias. No existe ningún archivo ejecutable llamado alias.
Para Usuarios de Oracle
Finalizar un proceso ofrece muchos usos – mayormente se utiliza para finalizar procesos fantasmas, procesos
que se encuentran en segundo plano y otros que han sido detenidos en respuesta a un cierre normal de los
comandos. Por ejemplo, cuando la instancia de base de datos de Oracle no se está cerrado debido a un
problema de memoria. Usted debe cerrarla finalizando uno de los procesos clave como pmon o smon. Esto no
debería realizarse todo el tiempo, solo cuando no haya opción.
Si quizás desee finalizar todas las sesiones sqlplus o todos los trabajos rman utilizando el comando de utilidad
kill. Los procesos Oracle Enterprise Manager se ejecutan como procesos perl; o procesos DBCA o DBUA, los
cuales quizás quiera finalizar rápidamente:
# /bin/kill perl rman perl dbca
dbua java
Existe también un uso más común de este comando. Cuando usted quiere finalizar una sesión de usuario en
la Base de Datos de Oracle, generalmente realiza alguna de las siguientes acciones:


Busca el SID y Serial# de la sesión
Finaliza la sesión utilizando el comando ALTER SYSTEM
Veamos qué sucede cuando desea finalizar la sesión del usuario SH.
SQL> select sid, serial#, status
2 from v$session
3* where username = 'SH';
SID
SERIAL# STATUS
---------- ---------- -------116
5784 INACTIVE
SQL> alter system kill
2 /
session '116,5784'
System altered.
La sesión ha finalizado; no obstante cuando usted controla en estado de
la sesión:
SID
SERIAL# STATUS
---------- ---------- -------116
5784 KILLED
Se muestra como KILLED (finalizada), pero no se ha eliminado por completo. Eso sucede porque Oracle
espera hasta que el usuario SH inicie su sesión e intente hacer algo, en ese momento recibe el mensaje
“ORA-00028: su sesión ha sido finalizada”. Luego de ese momento la sesión desaparece de V$SESSION.
Una manera más rápida de finalizar una sesión es eliminar el correspondiente proceso del servidor en el nivel
de Linux. Para hacerlo, primero busque el PID del proceso del servidor:
SQL> select spid
2 from v$process
3 where addr =
4 (
5
select paddr
6
from v$session
7
where username =
8 );
SPID
-----------------------30986
'SH'
El SPID es el ID de Proceso del proceso del servidor. Ahora puede finalizar este proceso:
# kill -9 30986
Ahora si verifica la visión V$SESSION, ésta desaparecerá inmediatamente. El usuario no recibirá el mensaje
instantáneamente; pero si intenta realizar una consulta a la base de datos, el obtendrá el siguiente mensaje:
ERROR at line 1:
ORA-03135: connection lost contact
Process ID: 30986
Session ID: 125 Serial number: 34528
Este en método rápido para finalizar una sesión, no obstante hay ciertos inconvenientes. La base de datos de
Oracle debe realizar una limpieza de sesión –deshacer cambios (rollback), etc. Y esto debería realizarse solo
cuando las sesiones se encuentran inactivas. Caso contrario, usted puede utilizar una de las dos otras
maneras de finalizar una sesión inmediatamente:
alter system disconnect session
alter system disconnect session
'125,35447' immediate;
'125,35447' post_transaction;
killall
A diferencia de la naturaleza dual del comando kill, killall es meramente una utilidad, es decir, es un programa
ejecutable en el directorio /usr/bin. El comando es similar a kill en funcionalidad pero en vez de finalizar un
proceso sobre la base de su PID, éste acepta el nombre del proceso como argumento. Por ejemplo, para
finalizar todos los procesos sqlplus, emita:
# killall sqlplus
Esto finaliza todos los procesos denominados sqlplus (los cuales usted tiene permiso de finalizar, por
supuesto). A diferencia del comando kill incorporado, usted no necesita conocer el ID de Proceso de los
procesos a finalizar.
Si el comando no finaliza el proceso o el proceso no responde a una señal TERM, usted puede enviar una
señal SIGKILL explícita como pudo ver en el comando kill utilizando la opción -s.
# killall -s SIGKILL sqlplus
Como en el comando kill, usted puede utilizar la opción -9 en lugar de -s SIGKILL. Para obtener un listado de
todas las señales disponibles, usted puede utilizar la opción -l.
# killall -l
HUP INT QUIT ILL TRAP ABRT IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM
TERM
STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF
WINCH IO PWR SYS
UNUSED
Para obtener el output completo del comando killall, utilice la opción -v:
# killall -v sqlplus
Killed sqlplus(26448)
Killed sqlplus(26452)
Killed sqlplus(26456)
Killed sqlplus(26457)
with
with
with
with
signal
signal
signal
signal
15
15
15
15
… and so on …
Algunas veces usted quizás quiera examinar el proceso antes de finalizarlo. La opción -i le permite ejecutarlo
interactivamente. Esta opción solicita su input antes de finalizarlo:
# killall -i sqlplus
Kill sqlplus(2537) ?
Kill sqlplus(2555) ?
Kill sqlplus(2555) ?
Killed sqlplus(2555)
(y/n) n
(y/n) n
(y/n) y
with signal 15
¿Qué sucede cuando usted aprueba un nombre de proceso equivocado?
# killall wrong_process
wrong_process: no process
killed
No existe ningún proceso de ejecución denominado wrong_process entonces no se ha finalizado nada y el
output lo ha mostrado claramente. Para eliminar este reclamo “no process killed”, utilice la opción -q. Esa
opción es muy útil en shell scripts en donde usted no puede analizar el output. En cambio, si usted desea
capturar el código de retorno del comando:
# killall -q wrong_process
# echo $?
1
El código de retorno (que se muestra en la variable shell $?) es “1”, en vez de “0”, lo cual indica una falla.
Usted puede controlar el código de retorno para examinar si el proceso killall resultó exitoso, es decir, si el
código de retorno es “0”.
Algo interesante en torno a este comando es que no se finaliza por si mismo. Por supuesto hace finalizar otros
comandos killall en otro sitio pero no en si mismo.
Para Usuarios de Oracle
Al igual que el comando kill, el comando killall también es utilizado para finalizar procesos. La mayor ventaja
de killall es la capacidad de desplegar el processid y la naturaleza interactiva que posee. Supongamos que
usted desea finalizar todos los procesos perl, java, sqlplus, rman y dbca pero no de manera interactiva; usted
puede emitir:
# killall -i -p perl sqlplus java rman dbca
Kill sqlplus(pgid 7053) ? (y/n) n
Kill perl(pgid 31233) ? (y/n) n
... and so on ...
Esto le permite ver el PID antes de finalizarlos, lo cual puede ser muy útil.
Conclusion
En este documento usted conoció los siguientes comandos (mostrados alfabéticamente)
dig
Una nueva versión de nslookup
ifconfig
Para desplegar información en las interfaces de red
kill
Para finalizar un proceso específico
killall
Para finalizar un proceso específico, un grupo de procesos y los nombres que coinciden
con un patrón
mesg
Para activar o desactivar la capacidad de los demás para desplegar algo en la terminal de
uno.
netstat
Para desplegar estadísticas y otras métricas sobre el uso de la interfaz de red
nslookup Para buscar el nombre de host de su dirección de IP o buscar la dirección de IP para su
nombre de host en DNS
talk
Para establecer un sistema de Mensajería Instantánea entre dos usuarios para lograr una
conversación en tiempo real
uptime
Para saber por cuánto tiempo ha estado funcionando el sistema y conocer su carga
promedio en 1, 5 y 15 minutos
w
Es una combinación de uptime y who
wall
Para desplegar texto en las terminales de todos los usuarios que han iniciado sesión
who
Para desplegar a todos los usuarios que han iniciado sesión en el sistema y para saber lo
que están haciendo
write
Para desplegar instantáneamente algo en la sesión de la terminal de un usuario específico
Como he mencionado anteriormente, no es mi intención presentarles cada comando disponible en los
sistemas Linux. Usted debe conocer solo algunos de ellos para administrar un sistema de manera efectiva y
esta serie le muestra los más importantes. Practíquelos en su entorno para comprenderlos mejor – con sus
parámetros y opciones. En el próximo documento, el último de ellos, usted aprenderá a administrar un entorno
Linux – en una máquina común, en una máquina virtual, y en la nube.
Guía para Maestría Avanzada en Comandos Linux, Parte 5:
Administración del Entorno Linux - Continuación
Por Arup Nanda
Publicado en octubre de 2009
En esta quinta y última presentación de la serie, describiremos más comandos y técnicas para
administrar un entorno Linux – incluyendo un entorno virtualizado.
Variables de las Palabras Claves de Shell
Cuando se encuentra en la línea de comando, usted utiliza un ''shell'' – generalmente el bash shell. En un
shell usted puede definir una variable y fijar un valor para luego ser recuperado. Aquí vemos un ejemplo de
una variable denominada ORACLE_HOME:
# export ORACLE_HOME=/opt/oracle/product/11gR2/db1/
Posteriormente puede referirse a la variable colocando el prefijo ''$'' delante del nombre de la variable, por ej.:
## cd $ORACLE_HOME
Esto se denomina variable definida por el usuario. Asimismo, existen numerosas variables definidas en el shell
mismo. Estas variables – cuyos nombres han sido predefinidos en el shell – controlan la manera en que usted
interactúa con el shell. Usted debería conocer estas variables (al menos algunas de las más importantes) para
mejorar la calidad y eficiencia de su trabajo.
PS1
Esta variable establece el command prompt de Linux. A continuación se muestra un ejemplo en donde el
comando cambia el prompt ''# '' establecido por defecto, a ''$ '':
''# '' to ''$ '':
# export PS1="$ "
$
¿Observa cómo el prompt cambió a $? Usted puede colocar aquí cualquier caracter para cambiar el prompt
que establezca por defecto. Las comillas dobles no son necesarias pero como queremos colocar un espacio
después del signo ''$'', debemos escribir las comillas al comienzo y al final.
¿Entonces eso es todo – para mostrar el prompt en un caracter predefinido o una cadena de caracteres? En
realidad no. Usted también puede incluir símbolos especiales en la variable para mostrar valores especiales.
Por ejemplo, el símbolo \u muestra el nombre de usuario que ha iniciado sesión y \h muestra el nombre de
host. Si utilizamos estos dos símbolos, el prompt puede personalizarse para mostrar quién ha iniciado sesión
y dónde:
$export PS1="\u@\h# "
oracle@oradba1#
Esto muestra el prompt tal como Oracle inició sesión en el servidor: oradba1 – y es suficiente para recordarle
quién es y en dónde se encuentra. También puede personalizar el prompt utilizando otro símbolo, \W, que
muestra el basename del directorio actual. Aquí vemos como aparece el prompt ahora:
# export PS1="\u@\h \W# "
oracle@oradba1 ~#
El directorio actual es HOME; por lo tanto éste se muestra como ''~''. Cuando usted cambia a un directorio
distinto, éste también cambia.
Agregar el directorio actual es una buena manera de recordarle en dónde se encuentra y cuáles son las
consecuencias de sus acciones. Ejecutar rm * produce un impacto diferente en /tmp que si usted se
encontrara en /home/oracle ¿no es así?
Existe también otro símbolo - \w. Pero tenga en cuenta que hay una gran diferencia entre \w y \W. La última
produce el basename del directorio actual mientras que la anterior muestra todo el directorio:
oracle@oradba1 11:59 AM db1# export PS1="\u@\h \@ \w# "
oracle@oradba1 12:01 PM /opt/oracle/product/11gR2/db1#
¿Nota la diferencia? En el prompt anterior, en donde se utilizó \W, se mostró solo el directorio db1, que es el
basename. En el siguiente prompt, en donde se utilizó \w, se desplegó el directorio completo
/opt/oracle/product/11gR2/db1.
En muchos casos mostrar el nombre del directorio completo en el prompt puede resultar de gran ayuda.
Supongamos que usted tiene tres Oracle Homes. Cada una tendrá un subdirectorio denominado db1. ¿Cómo
sabrá entonces en dónde se encuentra exactamente si solo se despliega ''db1''? Mostrar el directorio completo
no dejará lugar a dudas. No obstante, mostrar el directorio completo hará que el prompt sea más largo, lo cual
podría generar ciertos inconvenientes.
El símbolo ''\@'' muestra el tiempo real con el formato horas:minutos AM/PM:
# export PS1="\u@\h \@ \W# "
oracle@oradba1 11:59 AM db1#
Aquí vemos algunos otros símbolos que usted puede utilizar en la variable shell PS1:
El número de comando en el historial (se explicará más adelante)
\!
\d
\H
\T
\A
\t
La fecha en formato Día y Mes
El nombre del host con el nombre de dominio. \h es el nombre de host sin el dominio
Lo mismo que \@ pero incluyendo segundos.
El tiempo en horas:minutos, como en el formato \@, pero en un formato de 24 horas
Lo mismo que \A pero incluyendo los segundos incluidos
IFS
Esta variable ordena al shell tratar a las variables del shell como un conjunto o por separado. Si desea hacerlo
por separado, el valor establecido para la variable IFS se utiliza como separador. De ahí el nombre Input Field
Separator (IFS). Para demostrarlo, definamos una variable como se muestra a continuación.
# pfiles=initODBA112.ora:init.ora
En realidad, éstos son dos archivos: initODBA112.ora e init.ora. Ahora, si quiere desplegar la primera línea de
cada uno de estos archivos, deberá utilizar el comando head -1.
# head -1 $pfiles
head:cannot open `initODBA112.ora:init.ora'
for reading:
No such file or directory
El output lo dice todo; el shell interpretó la variable en su totalidad: `initODBA112.ora:init.ora', que no
corresponden al nombre de ningún archivo. Por eso el comando head falla. Si el shell interpretó el '':'' como
algún tipo de separador, tendría que haber realizado el trabajo adecuadamente. Por lo tanto, eso es lo que
debemos hacer al establecer la variable IFS:
# export IFS=":"
# head -1 $pfiles
==> initODBA112.ora <==
# first line of file initODBA112.ora
==> init.ora <==
# first line of file init.ora
Ahora sí. El shell expandió el comando head -1 $pfiles a head -1 initODBA112.ora y head -1 init.ora, y por lo
tanto, el comando se ejecutó correctamente.
PATH
Cuando usted utiliza un comando en Linux, este se encuentra en un shell -como puedo observarse en el
comando kill, de la Parte 4- o puede tratarse de un archivo ejecutable. Si es un archivo ejecutable, ¿cómo
saber en dónde se encuentra?
Tome por ejemplo el comando rm, el cual elimina algunos archivos. El comando puede obtenerse desde
cualquier directorio. Por supuesto que el archivo ejecutable rm no existe en todos los directorios, entonces
¿cómo sabe Linux en dónde buscar?
La variable PATH mantiene las localizaciones en donde el shell debe buscar ese ejecutable. Aquí vemos un
ejemplo de una configuración PATH:
# echo $PATH
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:.
Cuando usted ejecuta un comando como rm, el shell buscan un archivo rm en estas localizaciones, en el
siguiente orden:
/usr/kerberos/bin
/usr/local/bin
/bin
/usr/bin
/usr/X11R6/bin
. (the current directory)
Si el archivo no se encuentra en ninguna de estas localizaciones, el shell devuelve un mensaje de error -bash:
rm: command not found. Si usted desea agregar más localizaciones a la variable PATH, hágalo utilizando '':''
como separador.
¿Nota algo interesante arriba? La localización ''directorio actual'' se establece al final, no al comienzo. El
sentido común puede sugerirle que lo coloque al principio para que el shell busque primero un archivo
ejecutable en el directorio actual, antes de buscarlo en otro lado. Colocarlo al final hará al shell busque en el
directorio actual, al finalizar el proceso. ¿Pero hay alguna alternativa mejor?
Los expertos recomiendan que usted coloque el directorio actual (.) al final del comando PATH, no al
comienzo. ¿Por qué? Esta práctica es para una mayor seguridad. Supongamos que usted quiera
experimentar algunas ideas para mejorar los comandos shell comunes y sin advertirlo deja ese archivo en su
directorio de origen. Cuando usted inicie sesión, se encontrará en el directorio de origen y cuando ejecute ese
comando, usted no ejecutará el comando común sino el archivo ejecutable en su directorio de origen.
Esto podría ser desastroso en algunos casos. Supongamos que usted está utilizando una nueva versión del
comando ''cp'' y hay un archivo llamado cp en su directorio de origen. Este archivo posiblemente haga algún
daño. Si usted tipea ''cp somefile anotherfile'', su versión del archivo cp será ejecutada, causando daños.
Colocando el directorio actual al final, se ejecuta el comando ''cp'' normal, evitando dicho riesgo.
También evita el riesgo de que algún hacker coloque algún archivo de comando maligno como comando
común. Algunos expertos incluso sugieren eliminar el ''.'' del PATH para evitar cualquier ejecución involuntaria.
Si usted ha ejecutado algo en el directorio actual, simplemente utilice la anotación ./ como en este caso:
# ./mycommand
Esto ejecuta un archivo denominado mycommand en el actual directorio.
CDPATH
Es muy similar a PATH, esta variable extiende el alcance del comando cd más allá del directorio actual. Por
ejemplo, cuando usted tipea el comando cd como se muestra abajo:
# cd dbs
-bash: cd: dbs: No such file or directory
Tiene sentido ya que el directorio dbs no existe en el directorio actual. Se encuentra bajo
/opt/oracle/product/11gR2/db1. Es por ese motivo que el comando cd falla. Usted puede por supuesto ir al
directorio /opt/oracle/product/11gR2 y luego ejecutar con éxito el comando cd. Si desea incrementar el alcance
para incluir /opt/oracle/product/11gR2/db1, puede emitir:
# export CDPATH=/opt/oracle/product/11gR2/db1
Ahora, si usted emite el comando cd desde cualquier directorio:
# cd dbs
/opt/oracle/product/11gR2/db1/dbs
# pwd
/opt/oracle/product/11gR2/db1/dbs
El comando cd ahora busca otros directorios para ese subdirectorio.
Existen otras variables; pero éstas son las más utilizadas y usted debería saber dominarlas.
set
Este comando controla el comportamiento del shell. Tiene muchas opciones y argumentos pero explicaré los
más importantes.
Un error muy común que las personas cometen cuando sobrescriben comandos como cp y mv es sobrescribir
los archivos correctos sin darse cuenta. Usted puede evitar ese riesgo al utilizar un ''alias'' (como se muestra
en la Parte 1 de esta serie), por ej., utilizando mv –i en vez de mv. No obstante, ¿cómo puede evitar que
alguien o algún script sobrescriba los archivos utilizando el operador de re-direccionamiento (''>'')?
Veamos un ejemplo. Supongamos que usted tiene un archivo denominado very_important.txt. Alguien (o algún
script) involuntariamente utilizó algo como:
# ls -l > very_important.txt
El archivo inmediatamente se sobrescribió y usted pierde los contenidos originales del archivo. Para evitar
este riesgo, usted puede utilizar el comando set con la opción -o noclobber como se muestra abajo:
# set -o noclobber
Luego de este comando, si alguien intenta sobrescribir el archivo:
# ls -l > very_important.txt
-bash: very_important.txt: cannot overwrite existing file
El shell ahora evita que se sobrescriba un archivo existente. ¿Qué sucedería si desea sobrescribirlo? Usted
puede utilizar el operador >|.
# ls -l >| very_important.txt
Para desactivarlo:
# set +o noclobber
El comando set es también muy útil para utilizar el editor vi para editar comandos. Más adelante, en este
documento aprenderá a controlar los comandos que usted ha generado y cómo pueden ser reejecutados. Una
manera rápida de reejecutar el comando es repitiendo los comandos utilizando el editor vi. Para que éste
ejecute este comando primero:
# set -o vi
Ahora supongamos que usted está buscando un comando que contenga la letra ''v'' (como en vi, o vim, etc.).
Para buscar el comando, ejecute estas teclas. Las teclas que deben presionarse se encuentran dentro del
corchete:
# [Escape Key][/ key][v key][ENTER Key]
Esto muestra el último comando ejecutado que contenga la letra ''v''. El último comando en este caso fue set –
o vi; por lo tanto eso aparece en el command prompt.
# set -o vi
Si ese no es el comando que usted está buscando, presione la tecla ''n'' para obtener el siguiente comando
más reciente. De esta manera usted puede recorrer todos los comandos ejecutados con la letra ''v''. Cuando
usted ve el comando, puede presionar [tecla ENTER] para ejecutarlo. La búsqueda puede ser explícita si lo
desea. Supongamos que usted está buscando un comando mpstat ejecutado anteriormente. Todo lo que tiene
que hacer es ingresar esta cadena de búsqueda ''mpstat'':
# [Escape Key][/ key]mpstat[ENTER Key]
Supongamos que el comando de arriba muestra mpstat 5 5 y usted realmente desea ejecutar mpstat 10 10.
En vez de retipearlo, puede editar el comando en el editor vi. Para hacerlo, presione [Tecla Escape] y la tecla
[v], la cual colocará el comando en el editor vi. Ahora puede editar el comando que desee. Cuando lo guarda
en vi presionando :wq, el comando modificado será ejecutado.
type
En la Parte 4 usted conoció al comando kill, que es un comando especial – ya que es tanto una utilidad (un
ejecutable en algunos directorios) y un shell incorporado. Además, usted ya aprendió acerca de los alias en el
documento anterior. Algunas veces hay ciertos comandos utilizados en shell scripts – ''do'', ''done'', ''while'',
por mencionar algunos, que no son realmente comandos. Ellos son denominados shell keywords.
¿Pero cómo puede saber qué tipo de comando es? El comando type muestra eso precisamente. Aquí vemos
cómo debemos utilizarlo para mostrar los tipos de comandos mv, do, fc y oh.
# type mv do fc oh
mv is /bin/mv
do is a shell keyword
fc is a shell builtin
oh is aliased to `cd $ORACLE_HOME'
Muestra claramente que mv es una utilidad (junto con su ubicación), do es una clave utilizada dentro de los
scripts, fc es un shell built-in y oh es un alias (y muestra el elemento al que se lo asocia).
history
Cuando usted inicia sesión en el sistema Linux generalmente ejecuta una variedad de comandos en el
command prompt. ¿Pero cómo sabe usted qué comandos ha ejecutado? Quizás quiera saberlo por varias
razones – desea reejecutarlo sin volver a tipearlo, quiere asegurarse de haber ejecutado el comando
adecuado (por ej., eliminó el archivo adecuado), quiere verificar qué comandos fueron emitidos, entre otros
motivos. El comando history le brinda un historial de los comandos ejecutados.
# history
1064 cd dbs
1065 export CDPATH=/opt/oracle/product/11gR2/db1
1066 cd dbs
1067 pwd
1068 env
1069 env | grep HIST
… y así …
Observe los números antes de cada comando. Este es el número de comando o evento. Usted aprenderá a
utilizar esta característica más adelante. Si desea desplegar solo unas pocas líneas del historial en vez de
todas las que se encuentran disponibles, por ej., los cinco comandos más recientes:
# history 5
La mayor utilidad del comando history realmente proviene de su capacidad de reejecutar un comando sin
volver a tipearlo. Para ello, ingrese la marca ! seguida del evento o número de comando que precede al
nombre del comando en el output del historial. Para reejecutar el comando cd dbs que se muestra en el
número 1066, usted puede emitir:
# !1066
cd dbs
/opt/oracle/product/11gR2/db1/dbs
El comando !! (doble signo de exclamación) ejecuta el último comando ejecutado. También puede agregar
una cadena luego del comando !, lo cual reejecuta el último comando con el patrón como la cadena en la
posición inicial. El siguiente comando reejecuta el comando más reciente que comienza con cd:
# !cd
cd dbs
/opt/oracle/product/11gR2/db1/dbs
¿Qué sucede si desea reejecutar un comando que contiene una cadena (y no que comienza con una)? El
modificador ? realiza una asociación de patrones en los comandos. Para buscar un comando que se relacione
con él, emita:
# !?network?
cd network
/opt/oracle/product/11gR2/db1/network
También puede modificar el comando a ser reejecutado. Por ejemplo, supongamos que anteriormente había
establecido un comando cd /opt/oracle/product/11gR2/db1/network y desea reejecutarlo luego de agregar
/admin al final, usted emitirá:
# !1091/admin
cd network/admin
/opt/oracle/product/11gR2/db1/network/admin
fc
Este comando es un shell built-in utilizado para mostrar el historial del comando, como en history. La opción
más común es -l (la letra ''L'', no el número ''1'') que muestra los 16 comandos más recientes:
# fc -l
1055
echo $pfiles
1056
export IFS=
... and so on ...
1064
cd dbs
1065
export CDPATH=/opt/oracle/product/11gR2/db1
1066
cd dbs
También puede pedir a fc mostrar unos pocos comandos dando un rango de los números de eventos, por ej.,
1060 y 1064:
# fc -l 1060 1064
1060
pwd
1061
echo CDPATH
1062
echo $CDPATH
1063
cd
1064
cd dbs
La opción -l también requiere de otros dos parámetros – la cadena para realizar una asociación de patrones.
Aquí vemos un ejemplo en donde usted puede desplegar el historial de comandos que comienza con la
palabra echo hasta el comando más reciente que comienza con pwd.
# fc -l echo pwd
1062
echo $CDPATH
1063
cd
1064
cd dbs
1065
export CDPATH=/opt/oracle/product/11gR2/db1
1066
cd dbs
1067
pwd
Si desea reejecutar el comando cd dbs (número de comando 1066), puede simplemente ingresar ese número
después de fc con la opción -s:
# fc -s 1066
cd dbs
/opt/oracle/product/11gR2/db1/dbs
Otro importante uso del comando fc -l es la sustitución de comandos. Supongamos que usted desea ejecutar
un comando similar a 1066 (cd dbs) pero desea emitir cd network, no cd dbs, puede utilizar el argumento de
sustitución como se muestra a continuación:
# fc -s dbs=network 1066
cd network
/opt/oracle/product/11gR2/db1/network
Si omite la opción -s, como se muestra abajo:
# fc 1066
Se abre el archivo vi con el comando cd dbs dentro, el cual puede editar y ejecutar.
cpio
Considere esta situación: usted desea enviar un grupo de archivos a alguien o a alguna parte y no quiere
correr el riesgo de que sus archivos se pierdan. ¿Qué puede hacer para asegurarse de que eso no suceda?
Es simple. Si usted pone todos estos archivos en uno solo y envía este único archivo a su destino, puede
estar seguro de que todos los archivos van a llegar de manera segura.
El comando cpio tiene tres opciones principales:



-o (create) para crear un fichero (archive)
-i (extract) para extraer archivos de un fichero
-p (pass through) para copiar archivos a un directorio diferente
Cada opción tiene su propio grupo de subopciones. Por ejemplo, la opción -c se aplica para el caso de -i y -o
pero no en caso de -p. Veamos los grupos de opciones más importantes y cómo se utilizan.
La opción -v se utiliza para desplegar un output completo, lo cual puede ser útil en casos en que desee
obtener un feedback definido sobre lo que está sucediendo.
Primero, veamos cómo crear un fichero a partir de un grupo de archivos. Aquí colocamos todos los archivos
con la extensión ''trc'' en un directorio específico y luego los colocamos en un archivo denominado
myfiles.cpio:
$ ls *.trc | cpio -ocv > myfiles.cpio
+asm_ora_14651.trc
odba112_ora_13591.trc
odba112_ora_14111.trc
odba112_ora_14729.trc
odba112_ora_15422.trc
9 blocks
La opción -v fue utilizada para obtener el output completo y cpio nos mostró cada archivo que fue incorporado
al fichero. La opción -o se utilizó para crear un fichero. La opción -c se utilizó para que cpio escriba la
información del encabezado en ASCII, lo cual facilita el traspaso entre plataformas.
Otra opción es -O que acepta el output archive file como parámetro.
# ls *.trc | cpio -ocv -O mynewfiles.cpio
Para extraer los archivos:
$ cpio -icv < myfiles.cpio
+asm_ora_14651.trc
cpio: odba112_ora_13591.trc not created: newer or same age version exists
odba112_ora_13591.trc
Aquí las opciones -v y –i son utilizadas para obtener un output completo y para la extracción de archivos
desde los ficheros. La opción –c ha sido utilizada para ordenar a cpio a que lea la información del encabezado
como ASCII. Cuando cpio extrae un archivo y éste ya existe (como en el caso de odba112_ora_13591.trc), no
sobrescribe el archivo; sino que simplemente lo pasa por alto con un mensaje. Para que lo sobrescriba, utilice
la opción -u.
# cpio -icvu < myfiles.cpio
Para desplegar solamente los contenidos sin tener que extraerlos, utilice la opción –t junto con –i (extracción):
# cpio -it < myfiles.cpio
+asm_ora_14651.trc
odba112_ora_13591.trc
odba112_ora_14111.trc
¿Qué sucede si usted extrae un archivo que ya existe? Y aún así desea extraerlo pero tal vez con un nombre
distinto. Un ejemplo sería cuando usted intenta recuperar un archivo denominado alert.log (que es un archivo
log para una instancia Oracle) y no quiere sobrescribir el archivo alert.log actual.
Una de las opciones muy útiles es –r, que le permite reasignar un nombre a los archivos que se extraen, de
manera interactiva.
# cpio
rename
rename
rename
-ir < myfiles.cpio
+asm_ora_14651.trc -> a.trc
odba112_ora_13591.trc -> b.trc
odba112_ora_14111.trc -> [ENTER] which leaves the name alone
Si usted creó un fichero cpio de un directorio y desea extraer la misma estructura de directorio, utilice la
opción –d mientras lo extrae.
Mientras lo crea, puede agregar archivos a un fichero existente (append) utilizando la opción -A como se
muestra debajo:
# ls *.trc | cpio -ocvA -O mynewfiles.cpio
Los comandos tienen muchas otras opciones; no obstante, usted solo necesita conocer algunas de éstas para
poder utilizarlas de manera efectiva.
tar
Otro mecanismo para crear un fichero es tar. Originalmente creado para archivar unidades de cinta (de ahí el
nombre Tape Archiver), tar es un comando muy conocido por su simplicidad. Ofrece tres opciones principales



-c para crear un fichero (archive)
-x para extraer archivos de un fichero
-t para desplegar los archivos de un fichero
De esta forma es como se crea un fichero tar. La opción –f le permite asignar un nombre a un output file que
tar creará como fichero. En este ejemplo estamos creando un fichero denominado myfiles.tar a partir de todos
los archivos con extensión ''trc''.
# tar -cf myfiles.tar *.trc
Una vez creado, usted puede enumerar los contenidos de un fichero utilizando la opción –t.
# tar tf myfiles.tar
+asm_ora_14651.trc
odba112_ora_13591.trc
odba112_ora_14111.trc
odba112_ora_14729.trc
odba112_ora_15422.trc
Para mostrar el detalle de los archivos, utilice la opción –v (completa):
# tar tvf myfiles.tar
-rw-r----- oracle/dba
-rw-r----- oracle/dba
-rw-r----- oracle/dba
-rw-r----- oracle/dba
-rw-r----- oracle/dba
1150
654
654
654
654
2008-12-30
2008-12-26
2008-12-26
2008-12-26
2008-12-26
22:06:39
15:17:22
15:19:29
15:21:36
15:24:32
+asm_ora_14651.trc
odba112_ora_13591.trc
odba112_ora_14111.trc
odba112_ora_14729.trc
odba112_ora_15422.trc
Para extraer archivos del fichero, utilice la opción –x. Aquí vemos un ejemplo (la opción –v ha sido utilizada
para mostrar el output completo):
# tar xvf myfiles.tar
zip
La compresión es una parte muy importante de la administración de Linux. Quizás usted tenga que comprimir
varios archivos para hacer espacio a otros nuevos, o para enviarlos por email y así sucesivamente.
Linux ofrece numerosos comandos de compresión; aquí examinaremos los más comunes: zip y gzip.
El comando zip produce un archivo único al consolidar otros archivos y comprimirlos en un archivo zip. Aquí
vemos un ejemplo del comando:
# zip myzip *.aud
Se genera un archivo denominado myzip.zip con todos los archivos en el directorio asignado con la extensión
a .aud.
El zip acepta varias opciones. La más común es -9, que ordena al zip realizar la mayor compresión, mientras
se sacrifican los ciclos del CPU (y por lo tanto es el proceso más largo). La otra opción, -1, ordena justamente
lo contrario: realizar la compresión lo más rápido posible aunque se sacrifique la capacidad de compresión.
También puede proteger el archivo zip al encriptarlo con una contraseña. Sin la contraseña adecuada, el
archivo zip no puede ser desencriptado ( unzip). Esto se realiza con la opción –e (encriptar):
# zip -e ze *.aud
Enter password:
Verify password:
adding: odba112_ora_10025_1.aud (deflated 32%)
adding: odba112_ora_10093_1.aud (deflated 31%)
... y así ..
La opción -P permite dar una contraseña a la línea de comando. Debido a que esto permite a otros usuarios
ver la contraseña en plaintext al controlar los procesos o en el historial de comandos, la opción -e no es muy
recomendada.
# zip -P oracle zp *.aud
updating: odba112_ora_10025_1.aud (deflated 32%)
updating: odba112_ora_10093_1.aud (deflated 31%)
updating: odba112_ora_10187_1.aud (deflated 31%)
… y así ..
También puede controlar la integridad de los archivos zip utilizando al opción -T. Si el zipfile se encriptó con
una contraseña, debe proporcionarla.
# zip -T ze
[ze.zip] odba112_ora_10025_1.aud password:
test of ze.zip OK
Por supuesto que cuando usted comprime (zip) archivos, luego es necesario descomprimirlos (unzip). Y el
comando es unzip. Aquí vemos un simple ejemplo del uso del comando unzip para descomprimir el archivo
zip, ze.zip.
# unzip myfiles.zip
Si el archivo zip ha sido encriptado con una contraseña, se le pedirá esta contraseña. Cuando la ingrese, ésta
no se repetirá en la pantalla.
# unzip ze.zip
Archive: ze.zip
[ze.zip] odba112_ora_10025_1.aud password:
password incorrect--reenter:
password incorrect--reenter:
replace odba112_ora_10025_1.aud? [y]es, [n]o, [A]ll, [N]one, [r]ename: N
En el ejemplo de arriba, usted ingresó la contraseña incorrecta primero; por lo tanto el sistema volvió a
pedírsela. Luego de ingresarla correctamente, el comando unzip descubrió que ya existe un archivo
denominado odba112_ora_10025_1.aud; por lo tanto unzip requiere de su acción. Vea las alternativas –
también tiene la posibilidad de asignar un nuevo nombre para renombrar el archivo descomprimido.
¿Recuerda el zip protegido con contraseña que fue trasmitido en la línea de comando con el comando zip –P?
Usted puede descomprimir este archivo al trasmitir el comando en la línea de comando también, utilizando la
misma opción –P.
# unzip -P mypass zp.zip
La opción -P difiere de la opción -p. La opción -p ordena la descompresión para descomprimir archivos del
output estándar, el cual puede luego ser redirigido a otro archivo o programa.
Lo atractivo del comando zip es que es el más portátil. Usted puede comprimirlo en Linux y descomprimirlo en
OS X o Windows. La utilidad de descompresión está disponible para varias plataformas.
Supongamos que usted ha comprimido varios archivos en varios subdirectorios que se encuentran en un
directorio. Cuando usted descomprime este archivo, se crean los subdirectorios que sean necesarios. Si
desea ver todos los archivos a ser descomprimidos en el actual directorio, utilice en cambio la opción -j.
# unzip -j myfiles.zip
Una de las combinaciones más útiles es utilizar el comando tar para consolidar los archivos y comprimir el
archive file resultante por medio del comando zip. En lugar de realizar un proceso de dos pasos con tar y zip,
puede pasar el output de tar a zip como se muestra a continuación:
# tar cf - . | zip myfiles adding: - (deflated 90%)
El caracter especial ''-'' en zip representa el nombre del archivo. El comando tar de arriba crea un zip llamado
myfiles.zip.
De manera similar, mientras descomprime el archivo descomprimido y extrae los archivos del fichero zip,
usted puede eliminar el proceso de dos pasos y realizar ambos en uno solo:
# unzip -p myfiles | tar xf -
gzip
El comando gzip (denominación corta de GNU zip), es otro comando para comprimir archivos. Intenta
reemplazar la antigua utilidad de compresión UNIX.
La principal diferencia práctica entre zip y gzip es que la primera crea un archivo zip a partir de un conjunto de
archivos mientras que la última crea un archivo comprimido para cada archivo input. Vemos aquí un ejemplo:
# gzip odba112_ora_10025_1.aud
Observe que no pide un nombre para el archivo zip. El comando gzip toma cada archivo (por ej.,
odba112_ora_10025_1.aud) y simplemente crea un archivo zip denominado odba112_ora_10025_1.aud.gz.
Asimismo, observe cuidadosamente este punto, se elimina el archivo original odba112_ora_10025_1.aud. Si
usted pasa un grupo de archivos como parámetros al comando:
# gzip *
Se crea un archivo zip con la extensión .gz para cada uno de estos archivos presentes en el directorio. Al
principio, el directorio contenía estos archivos:
a.txt
b.pdf
c.trc
Después de utilizar el comando gzip *, los contenidos del directorio serán:
a.txt.gz
b.pdf.gz
c.trc.gz
También se utiliza el mismo comando para descomprimir (o uncompress, o decompress). La opción es,
intuitivamente, -d para descomprimir los archivos comprimidos por gzip
Para verificar los contenidos del archivo comprimido con gzip y el índice de compresión, puede utilizar la
opción -l. En verdad no comprime ni descomprime nada, simplemente muestra los contenidos.
# gzip -l *
compressed
698
464
466
466
uncompressed
1150
654
654
654
ratio
42.5%
35.2%
34.9%
34.9%
uncompressed_name
+asm_ora_14651.trc
odba112_ora_13591.trc
odba112_ora_14111.trc
odba112_ora_14729.trc
463
2557
654 35.3% odba112_ora_15422.trc
3766 33.2% (totals
También puede comprimir los archivos en un directorio, utilizando la opción (-r). Para comprimir todos los
archivos que se encuentran en el directorio log, utilice:
# gzip -r log
Para controlar la integridad de un archivo comprimido con gzip, utilice la opción -t:
# gzip -t myfile.gz
Cuando desea crear un nombre distinto para el archivo comprimido con gzip, no el .gz establecido por defecto,
debería utilizar la opción –c. Esto ordena al comando gzip escribir el output estándar al cual puede ser
direccionado el archivo. Puede utilizar la misma técnica para colocar más de un archivo en el mismo archivo
comprimido con gzip. Aquí vemos dos archivos comprimidos - odba112_ora_14111.trc,
odba112_ora_15422.trc – en el mismo archivo comprimido denominado 1.gz.
# gzip -c
odba112_ora_14111.trc odba112_ora_15422.trc > 1.gz
Observe cuando se despliega el contenido del archivo comprimido:
# gzip -l 1.gz
compressed
uncompressed ratio uncompressed_name
654 -35.9% 1
El índice de compresión mostrado simplemente se aplica al último archivo en el listado (es por eso que
muestra un tamaño menor para el original que para el comprimido). Cuando usted descomprime este archivo,
ambos archivos originales se despliegan uno tras otro y ambos se descomprimen adecuadamente.
La opción -f obliga al output a sobrescribir los archivos, si ese es el caso. La opción –v muestra el output de
manera más completa. Aquí vemos un ejemplo:
# gzip -v *.trc
+asm_ora_14651.trc:
odba112_ora_13591.trc:
odba112_ora_14111.trc:
odba112_ora_14729.trc:
odba112_ora_15422.trc:
42.5%
35.2%
34.9%
34.9%
35.3%
------
replaced
replaced
replaced
replaced
replaced
with
with
with
with
with
+asm_ora_14651.trc.gz
odba112_ora_13591.trc.gz
odba112_ora_14111.trc.gz
odba112_ora_14729.trc.gz
odba112_ora_15422.trc.gz
Un comando relacionado es el comando zcat. Si desea desplegar el contenido del archivo comprimido con
gzip sin descomprimirlo primero, utilice el comando zcat:
# zcat 1.gz
El comando zcat es similar a gzip -d | cat en el archivo; pero no descomprime verdaderamente el archivo.
Como el comando zip, gzip también acepta opciones para los grados de compresión:
# gzip -1 myfile.txt … Least compression consuming least CPU and fastest
# gzip -9 myfile.txt … Most compression consuming most CPU and slowest
El comando gunzip está disponible, y es equivalente a gzip -d (para descomprimir un archivo comprimido con
gzip)
Administración de Linux en un Entorno Virtual
Linux se utiliza en los centros de datos de todo el mundo. Tradicionalmente, el concepto de “servidor” se
relaciona con una máquina física distinta de otras máquinas físicas. Esto ha sido así hasta la llegada de la
virtualización, en donde un único servidor podía ser dividido para así convertirse en varios servidores virtuales,
cada uno como si funcionaran de manera independientes con la red. Contrariamente, un ''grupo'' de
servidores integrado por varios servidores físicos puede dividirse a medida que sea necesario.
Debido a que ya no existe una relación uno-a-uno entre un servidor físico y uno lógico o virtual, algunos
conceptos podrían resultar confusos. Por ejemplo, ¿qué es la memoria disponible? ¿Es la memoria disponible
de: (1) el servidor virtual, (2) el servidor físico individual desde donde el servidor virtual se ha dividido, o (3) el
grupo total de servidores del que el servidor virtual es parte? Es así entonces que los comandos de Linux
pueden comportarse de manera un poco distinta cuando se ejecutan en un entorno virtual.
Además, el entorno virtual también debe ser administrado, y para ello existen algunos comandos que se
especializan en la administración de infraestructuras virtualizadas. En esta sección usted conocerá los
comandos especializados y las actividades relacionadas al entorno virtual. Utilizaremos una Oracle VM como
ejemplo.
Uno de los componentes clave de la virtualización en un entorno Oracle VM es Oracle VM Agent, el cual debe
estar activo para que Oracle VM funcione completamente. Para controlar si el agente está activo, debe ir al
servidor de Administración (provm1, en este caso) y utilizar el comando service:
[root@provm1 vnc-4.1.2]# service ovs-agent status
ok! process OVSMonitorServer exists.
ok! process OVSLogServer exists.
ok! process OVSAgentServer exists.
ok! process OVSPolicyServer exists.
ok! OVSAgentServer is alive.
El output muestra claramente que todos los procesos clave se encuentran activos. Si no están activos es
porque pueden haberse desconfigurado y quizás usted quiera volver a configurarlos (o configurarlos por
primera vez):
# service ovs-agent configure
El mismo comando service también se utiliza para iniciar, reiniciar y frenar los procesos del agente:
service ovs-agent start
service ovs-agent restart
service ovs-agent stop
No obstante, la mejor manera de administrar el entorno es por medio de la consola GUI, la cual se basa en la
Web. Manager Webpage está disponible en el servidor Admin, en el puerto 8888, por defecto. Usted puede
obtenerlo al ingresar lo siguiente en cualquier navegador de Web (suponiendo que el nombre del servidor
admin es oradba2).
http://oradba2:8888/OVS
Inicie sesión como admin y la contraseña que usted creó durante
la instalación. Esto le trae la siguiente pantalla:
La parte inferior de la pantalla muestra los servidores físicos del grupo de servidores. Aquí el grupo de
servidores se denomina provmpool1 y el IP del servidor es 10.14.106.0. Desde esta pantalla, usted puede
reiniciar el servidor, apagarlo, quitarlo del grupo y editar los detalles del servidor. También puede agregar un
nuevo servidor físico a este grupo al hacer click en el botón Add Server.Al hacer click en la dirección de IP del
servidor, aparecen los detalles de ese servidor físico, como se muestra debajo:
Tal vez lo más útil sea la etiqueta Monitor. Si hace click en ella, se muestra la utilización de los recursos del
servidor – CPU, disco y memoria, como se muestra abajo. Desde esta página usted puede controlar
visualmente si los recursos están siendo desaprovechados o si se están utilizando en exceso, o si usted
necesita agregar más servidores físicos, entre otras cosas:
Volviendo a la página principal, la etiqueta Server Pools muestra los numerosos grupos de servidores
definidos. Aquí puede definir otro grupo, finalizarlo, restablecer el grupo y así sucesivamente:
Si desea agregar un usuario u otro administrador, usted debe hacer click en la etiqueta Administration.
Existe un administrador por defecto denominado ''admin''. Usted puede controlar todos los admins aquí y
establecer sus prioridades, como las direcciones de email, los nombres, etc.:
Tal vez la actividad más frecuente que usted realice sea la administración de máquinas virtuales. Casi todas
las funciones se encuentran el la etiqueta Virtual Machines en la página principal. Ésta muestra las VM
creadas hasta el momento. Aquí vemos una captura de pantalla que muestra dos máquinas denominadas
provmlin1 y provmlin2:
La VM denominada provmlin2 se muestra como ''powered off'', es decir, aparece como inactivo para los
usuarios finales. La otra – provmlin1 – presenta algún tipo de error. Primero comencemos con VM provmlin2.
Seleccione el botón radio cerca de éste y haga click en el botón Power On. Después de un momento se
mostrará como ''Running'', tal como se ve abajo:
Si hace click en el nombre VM, podrá ver los detalles de VM, como se observa debajo:
Desde la pantalla de arriba podemos saber qué VM ha sido asignada con 512MB de RAM; ejecuta Oracle
Enterprise Linux 5; solo presenta un núcleo, etc. La página también brinda información clave, por ejemplo, que
el puerto VNC port: 5900. Utilizando esto, usted puede poner en funcionamiento la terminal VNC de esta
máquina virtual. Aquí he utilizado un visualizador VNV, con el nombre de host provm1 y el puerto 5900:
Esto inicia la sesión VNC en el servidor. Ahora puede iniciar una sesión terminal:
Debido a que el puerto VNC 5900 apunta a la máquina virtual denominada provmlin4, aparece la terminal en
esa VM. Ahora usted puede emitir sus comandos Linux en esta terminal.
xm
En el servidor sobre el que se ejecutan las máquinas virtuales, los comandos de medición de desempeño
como uptime (descriptos en la Parte 3) y top (descriptos en la Parte 2) tienen distintos significados en
comparación con sus contrapartes del servidor físico. En un servidor físico el uptime se refiere a la cantidad de
tiempo en que el servidor ha estado activo, mientras que en un mundo virtual podría ser ambiguo –
refiriéndose a los servidores virtuales individuales en ese servidor. Para medir el desempeño del grupo de
servidores físicos, utilice un comando distinto, xm. Los comandos son emitidos desde este comando principal.
Por ejemplo, para enumerar los servidores virtuales, puede utilizar la lista del comando xm:
[root@provm1 ~]# xm list
Name
22_provmlin4
Domain-0
ID
1
0
Mem VCPUs
512
1
532
2
State
Time(s)
-b---27.8
r----- 4631.9
Para medir el uptime, usted podría utilizar xm uptime:
[root@provm1 ~]# xm uptime
Name
22_provmlin4
Domain-0
ID
1
0
Uptime
0:02:05
8:34:07
Los demás comandos disponibles en xm se muestran a continuación. Muchos de estos comandos pueden
también ejecutarse a través de GUI.
console
create
new
delete
destroy
dump-core
Adjunta un elemento a la consola de <Domain>.
Crea un dominio basado en <ConfigFile>.
Agrega un dominio a la gestión de dominio Xend
Elimina un dominio desde la gestión de dominio Xend.
Finaliza un dominio inmediatamente.
Aplica
dump core para un dominio específico.
help
Despliega este mensaje.
list
Enumera la información sobre todos/algunos dominios.
mem-set
Establece el uso de memoria actual para un dominio.
migrate
Migra un dominio a otra máquina.
pause
Pausa la ejecución de un dominio.
reboot
Reinicia un dominio.
restore
Restablece un dominio desde el estado guardado.
resume
Reanuda un dominio administrado por Xend.
save
Guarda el estado de un dominio para restablecerlo luego.
shell
Lanza un shell interactivo.
shutdown
Cierra un dominio.
start
Inicia un dominio administrado por Xend.
suspend
Suspende un dominio administrado por Xend.
top
Monitorea un host y los dominios en tiempo real.
unpause
Reanuda un dominio en pausa.
uptime
Imprime el tiempo de actividad para un dominio.
vcpu-set
Establece la cantidad de VCPUs activos permitidos para el
dominio.
Veamos los más utilizados. Además de uptime, usted también puede estar interesado en el desempeño del
sistema por medio del comando top. Este comando xm top actúa como el comando top en el shell del servidor
regular – se actualiza automáticamente, tiene algunas claves para mostrar distintos tipos de mediciones como
CPU, I/O, Red, etc. Aquí vemos el output del comando xm top básico:
xentop - 02:16:58
Xen 3.1.4
2 domains: 1 running, 1 blocked, 0 paused, 0 crashed, 0 dying, 0 shutdown
Mem: 1562776k total, 1107616k used, 455160k free
CPUs: 2 @ 2992MHz
NAME STATE
CPU(sec) CPU(%) MEM(k) MEM(%) MAXMEM(k)MAXMEM(%) VCPUS NETS
22_provmlin4 --b--27
0.1 524288
33.5
1048576
67.1 1 ...
Domain-0 -----r
4647
23.4 544768 34.9
no
limit n/a
2 ...
22_provmlin4 --b--Domain-0 -----r
1
8
9
68656
154
2902548
1
0
06598
0
1207
0
0
0
Muestra estadísticas como el porcentaje de CPU utilizado, la memoria utilizada, etc., para cada Máquina
Virtual. Si presiona N, verá las actividades de red como se muestra a continuación:
xentop - 02:17:18
Xen 3.1.4
2 domains: 1 running, 1 blocked, 0 paused, 0 crashed, 0 dying, 0 shutdown
Mem: 1562776k total, 1107616k used, 455160k free
CPUs: 2 @ 2992MHz
Net0 RX: 180692bytes
2380pkts
0err
587drop
TX:
9414bytes
Domain-0 -----r 4650
22.5 544768
34.9
no limit n/a
2
8
68665 2902570
0
0
0
0
0
Net0 RX:2972232400bytes 2449735pkts 0err 0drop TX:70313906bytes ...
Net1 RX:
0bytes 0pkts
0err 0drop TX:
0bytes ...
Net2 RX:
0bytes 0pkts
0err 0drop TX:
0bytes ...
Net3 RX:
0bytes 0pkts
0err 0drop TX:
0bytes ...
Net4 RX:
0bytes 0pkts
0err 0drop TX:
0bytes ...
Net5 RX:
Net6 RX:
Net7 RX:
Net0
Net1
Net2
Net3
Net4
Net5
Net6
Net7
RX:
RX:
RX:
RX:
RX:
RX:
RX:
RX:
0bytes
0bytes
0bytes
1017641pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0pkts
0err
0err
0err
0err
0err
0err
0err
0err
0err 0drop TX:
0err 0drop TX:
0err 0drop TX:
0bytes ...
0bytes ...
0bytes ...
0drop
0drop
0drop
0drop
0drop
0drop
0drop
0drop
Presionando V se ven las estadísticas de VCPU (CPU Virtual).
xentop - 02:19:02
Xen 3.1.4
2 domains: 1 running, 1 blocked, 0 paused, 0 crashed, 0 dying, 0 shutdown
Mem: 1562776k total, 1107616k used, 455160k free
CPUs: 2 @ 2992MHz
NAME STATE
CPU(sec) CPU(%) MEM(k) MEM(%) MAXMEM(k) MAXMEM(%) VCPUS
...
22_provmlin4 --b--28
0.1
524288
33.5
1048576
67.1
...
NETS NETTX(k) NETRX(k) VBDS
VBD_OO
VBD_RD
VBD_WR SSID
1
1
9
282
1
06598
1220
0
VCPUs(sec):
0:
28s
Domain-0 -----r
4667
limit
n/a
2
8
68791 2902688
0
VCPUs(sec):
0:
2753s
1.6
00
1:
544768
0
34.9
no
0
1913s
Examinemos algunas actividades bastante comunes – una de las cuales es la distribución de la memoria
disponible entre las VM. Supongamos que usted quiera tener cada VM de 256 MB de RAM, debería utilizar el
comando xm mem-set como se muestra abajo. Luego debería utilizar el comando xm list para confirmarlo.
[root@provm1 ~]# xm mem-set 1 256
[root@provm1 ~]# xm mem-set 0 256
[root@provm1 ~]# xm list
Name
ID
Mem VCPUs
22_provmlin4
1
256
1
Domain-0
0
256
2
State
-b---r-----
Time(s)
33.0
4984.4
Conclusion
Con esto concluimos la extensa serie de cinco presentaciones sobre comandos avanzados de Linux. Como
mencioné al comienzo de esta serie, Linux tiene numerosos comandos que son útiles en muchos casos, y
nuevos comandos que van desarrollándose e incorporándose gradualmente. Conocer todos los comandos
disponibles no es tan importante como saber cuáles se adaptan mejor a sus necesidades.
En esta serie he presentado y explicado algunos comandos necesarios para realizar la mayoría de sus tareas
diarias. Si usted practica estos pocos comandos, junto con sus opciones y argumentos, podrá manejar
cualquier infraestructura de Linux con facilidad.
Gracias por leer esta serie y mucha suerte.