viernes, 29 de mayo de 2015

SCRIPTS DE ORACLE PARA QUE SIRVEN $ORACLE_HOME/rdbms/admin

$ORACLE_HOME/rdbms/admin
 
File Name Description
addmrpt.sql Automatic Database Diagnostic Monitor (ADDM) report
addmrpti.sql Automatic Database Diagnostic Monitor (ADDM) report
addmtmig.sql Post upgrade script to load new ADDM task metadata tables for task migration
ashrpt.sql Active Session History (ASH) report
ashrpti.sql Active Session History (ASH) report with RAC and Standby Database support
ashrptistd.sql Active Session History (ASH) report helper script for obtaining user input when run on a Standby
awrblmig.sql AWR Baseline Migration
awrddinp.sql Retrieves dbid,eid,filename for SWRF and ADDM Reports
awrddrpi.sql Workload Repository Compare Periods Report
awrddrpt.sql Produces Workload Repository Compare Periods Report
awrextr.sql Helps users extract data from the AWR
awrgdinp.sql AWR global compare periods report input variables
awrgdrpi.sql Workload repository global compare periods report
awrgdrpt.sql AWR global differences report
awrginp.sql AWR global input
awrgrpt Script defaults the dbid to that of the current instance connected-to, then calls awrgrpti.sql to produce the Workload Repository RAC report
awrgrpti Report on RAC-wide differences between values recorded in two snapshots
awrinfo.sql Outputs general Automatic Workload Repository (AWR) information such as the size and data distribution
awrinpnm.sql Query the user for the name of the report file to be generated. The script generates a default name based on the instance number, begin snap id, end snap id and the type of report to be generated (text or html). This code is used for the SWRF reports, SQL Reports and ADDM reports.
awrinput.sql Common code used for SWRF reports and ADDM
awrload.sql Uses DataPump to load information from dump files into the AWR
awrrpt.sql Automated Workload Repository (AWR) report
awrrpti.sql Automated Workload Repository (AWR) report
awrsqrpi.sql Reports on differences in values recorded in two different snapshots
awrsqrpt.sql Produces a workload report on a specific SQL statement
awrupd12.sql Updates AWR data to version 12c. It only modifies AWR data that has been imported using awrload.sql, or data from before changing the database DBID
catalog.sql Builds the data dictionary views
catawrtb.sql Builds the AWR tables
catblock.sql Creates views that dynamically display lock dependency graphs
catclust.sql Builds DBMS_CLUSTDB built-in package
caths.sql Installs packages for administering heterogeneous services
catio.sql Allows I/O to be traced on a table-by-table basis
catnoawr.sql Script to uninstall AWR features
catplan.sql Builds PLAN_TABLE$: A public global temporary table version of PLAN_TABLE
dbfs_create_filesystem.sql DBFS create file system script
dbfs_create_filesystem_advanced.sql DBFS create file system script
dbfs_drop_filesystem.sql DBFS drop file system
dbmshptab.sql Permanent structures supporting DBMS_HPROF hierarchical profiler
dbmsiotc.sql Analyzes chained rows in index-organized tables
dbmspool.sql Enables DBA to lock PL/SQL packages, SQL statements, and triggers into the shared pool
dumpdian.sql Dumps Diana out of a database in a human-readable format (exec dumpdiana.dump('DMMOD_LIB')
epgstat.sql Shows various status of the embedded PL/SQL gateway and the XDB HTTP listener. It should be run by a user with XDBADMIN and DBA roles
hangdiag.sql Hang analysis/diagnosis script
noncdb_to_pdb.sql Given a DB with proper obj$ common bits set, converts it to a proper PDB by deleting unnecessary metadata
prgrmanc.sql Purges from RMAN Recovery Catalog the records marked as deleted by the user
recover.bsq Creates recovery manager tables and views ... read the header very carefully if considering performing an edit
sbdrop.sql SQL*PLUS command file drop user and tables for readable standby
sbduser.sql SQL*Plus command file to DROP user which contains the standby statspack database objects
sbreport.sql This script calls sbrepins.sql to produce standby statspack report. It must run as the standby statspack owner, stdbyperf
scott.sql Creates the SCOTT schema objects and loads the data
secconf.sql Secure configuration script: Laughable but better than the default
spauto.sql SQL*PLUS command file to automate the collection of STATPACK statistics
spawrrac.sql Generates a global AWR report to report performance statistics on all nodes of a cluster
spcreate.sql Creates the STATSPACK user, table, and package
sppurge.sql Purges a range of STATSPACK data
sprepcon.sql STATSPACK report configuration
sprepsql.sql Defaults the dbid and instance number to the current instance connected-to, then calls sprsqins.sql to produce the standard Statspack SQL report
sprsqins.sql STATSPACK report
sql.bsq Drives the creation of the Oracle catalog and data dictionary objects
tracetab.bsq Creates tracing table for the DBMS_TRACE built-in package
userlock.sql Routines that allow the user to request, convert and release locks
utlchain.sql Creates the default table for storing the output of the analyze list chained rows command
utlchn1.sql Creates the default table for storing the output of the analyze list chained rows command
utlconst.sql Constraint check utility to check for valid date constraints
utldim.sql Build the Exception table for DBMS_DIMENSION.VALIDATE_DIMENSION
utldtchk.sql This utility script verifies that a valid database object has correct dependency$ timestamps for all its parent objects. Violation of this invariant can show up as one of the following:
  • Invalid dependency references [DEP/INV] in library cache dumps
  •  ORA-06508: PL/SQL: could not find program unit being called
  • PLS-00907: cannot load library unit %s (referenced by %s)
  • ORA-00600[ kksfbc-reparse-infinite-loop]
utldtree.sql Shows objects recursively dependent on given object
utledtol.sql Creates the outline table OL$, OL$HINTS, and OL$NODES in a user schema for working with stored outlines
utlexcpt.sql Builds the Exception table for constraint violations
utlexpt1.sql Creates the default table (EXCEPTIONS) for storing exceptions from enabling constraints. Can handle both physical and logical rowids.
utlip.sql Can be used to invalidate all existing PL/SQL modules (procedures, functions, packages, types, triggers, views) in a database so that they will be forced to be recompiled later either automatically or deliberately.
utllockt.sql Prints the sessions in the system that are waiting for locks, and the locks they are waiting for
utlpwdmg.sql Creates the default Profile password VERIFY_FUNCTION
utlrdt.sql recompiles all DDL triggers in UPGRADE mode at the end of one of three operations:
  • DB upgrade
  • utlirp to invalidate and recompile all PL/SQL
  • dbmsupgnv/dbmsupgin to convert PL/SQL to native/interpreted
utlrp.sql Recompiles all invalid objects in the database.
utlscln.sql Copies a snapshot schema from another snapshot site
utlsxszd.sql Calculates the required size for the SYSAUX tablespace
utltkprf.sql Grants public access to all views used by TKPROF with verbose=y option
utluiobj.sql Outputs the difference between invalid objects post-upgrade and those objects that were invalid preupgrade
utlusts.sql Utility Upgrade Status: Presents Post-upgrade Status in either TEXT or XML
utlu112s.sql This script provides information about databases that have been upgraded to 12.1
utlvalid.sql Creates the default table for storing the output of the analyze validate command on a partitioned table
utlxaa.sql Defines a user-defined workload table for SQL Access Advisor. The table is used as workload source for SQL Access Advisor where a
user can insert SQL statements and then specify the table as a workload source.
utlxmv.sql Creates the MV_CAPABILITIES_TABLE for DBMS_MVIEW.EXPLAIN_MVIEW
utlxplp.sql Displays Explain Plan from PLAN_TABLE using DBMS_XPLAN built-in. Includes parallel run information
utlxpls.sql Displays Explain Plan from PLAN_TABLE using DBMS_XPLAN built-in. Does not include parallel query information.
utlxrw.sql Builds the REWRITE_TABLE for EXPLAIN_REWRITE tests
xdbvlo.sql Validates XML DB schema objects
 
$ORACLE_HOME/sqlplus/admin
File Name Description
glogin.sql SQL*Plus global login "site profile" file. Add SQL*Plus commands here to executed them when en a user starts SQL*Plus and/or connects
plustrce.sql Creates the PLUSTRACE role required to use AUTOTRACE
pupbld.sql Creates PRODUCT_USER_PROFILE

miércoles, 27 de mayo de 2015

Guía para Maestría Avanzada en Comandos Linux, Parte 5: Administración del Entorno Linux - Continuación



Guía para Maestría Avanzada en Comandos Linux, Parte 5: Administración del Entorno Linux - Continuación

 
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)
\dLa fecha en formato Día y Mes
\HEl nombre del host con el nombre de dominio. \h es el nombre de host sin el dominio
\TLo mismo que \@ pero incluyendo segundos.
\AEl tiempo en horas:minutos, como en el formato \@, pero en un formato de 24 horas
\tLo 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 -ir < myfiles.cpio
rename +asm_ora_14651.trc -> a.trc
rename odba112_ora_13591.trc -> b.trc
rename 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     1150 2008-12-30 22:06:39 +asm_ora_14651.trc
-rw-r----- oracle/dba      654 2008-12-26 15:17:22 odba112_ora_13591.trc
-rw-r----- oracle/dba      654 2008-12-26 15:19:29 odba112_ora_14111.trc
-rw-r----- oracle/dba      654 2008-12-26 15:21:36 odba112_ora_14729.trc
-rw-r----- oracle/dba      654 2008-12-26 15:24:32 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        uncompressed  ratio uncompressed_name
                698                1150  42.5% +asm_ora_14651.trc
                464                 654  35.2% odba112_ora_13591.trc
                466                 654  34.9% odba112_ora_14111.trc
                466                 654  34.9% odba112_ora_14729.trc

                463                 654  35.3% odba112_ora_15422.trc
                2557                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:      42.5% -- replaced with +asm_ora_14651.trc.gz
odba112_ora_13591.trc:   35.2% -- replaced with odba112_ora_13591.trc.gz
odba112_ora_14111.trc:   34.9% -- replaced with odba112_ora_14111.trc.gz
odba112_ora_14729.trc:   34.9% -- replaced with odba112_ora_14729.trc.gz
odba112_ora_15422.trc:   35.3% -- replaced with 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                            ID  Mem VCPUs      State   Time(s)
22_provmlin4                    1   512     1      -b----     27.8
Domain-0                        0   532     2       r-----  4631.9
Para medir el uptime, usted podría utilizar xm uptime:
[root@provm1 ~]# xm uptime
Name                             ID  Uptime 
22_provmlin4                      1  0:02:05
Domain-0                          0  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      Adjunta un elemento a la consola de .
create      Crea un dominio basado en . 
new         Agrega un dominio a la gestión de dominio Xend 
delete      Elimina un dominio desde la gestión de dominio Xend.
destroy     Finaliza un dominio inmediatamente.
dump-core   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---     1        9      154    1     06598     1207    0
Domain-0 -----r         8    68656  2902548    0     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:        0bytes  0pkts       0err 0drop TX:       0bytes ...
Net6 RX:        0bytes  0pkts       0err 0drop TX:       0bytes ...
Net7 RX:        0bytes  0pkts       0err 0drop TX:       0bytes ...

Net0 RX:   1017641pkts  0err 0drop
Net1 RX:         0pkts  0err 0drop
Net2 RX:         0pkts  0err 0drop
Net3 RX:         0pkts  0err 0drop
Net4 RX:         0pkts  0err 0drop
Net5 RX:         0pkts  0err 0drop
Net6 RX:         0pkts  0err 0drop
Net7 RX:         0pkts  0err 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    1.6     544768   34.9   no limit     n/a   
2    8    68791  2902688   0       00        0       0

  VCPUs(sec):   0:       2753s  1:       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     State   Time(s)
22_provmlin4             1   256      1     -b----     33.0
Domain-0                 0   256      2     r-----   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.

Guía para Maestría Avanzada en Comandos Linux, Parte 4: Administración del Entorno Linux



Guía para Maestría Avanzada en Comandos Linux, Parte 4: Administración del Entorno Linux

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:

Figure1



É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  hw   
                            
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  State      
tcp        0      0 prolin1:31027 prolin1:5500     TIME_WAIT 
tcp        4      0 prolin1l:1521 applin1:40205    ESTABLISHED 
tcp        0      0 prolin1l:1522 prolin1:39957    ESTABLISHED 
tcp        0      0 prolin1l:3938 prolin1:31017    TIME_WAIT
tcp        0      0 prolin1l:1521 prolin1:21545    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. la columna del extremo izquierdo denominada “ Proto” muestra el tipo de conexión – tcp en este caso.
  2. 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 Send-Q, descripta a continuación.
  3. 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.
  4. Local Address se refiere al origen de la conexión y el número de puerto del programa.
  5. 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.
  6. La columna State muestra el estado de la conexión. Aquí vemos algunos valores comunes.
    • 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.
    • CLOSED – la conexión se ha cerrado, es decir, no está siendo utilizada.
    • TIME_WAIT – la conexión se está cerrando pero aún hay paquetes pendientes en la red.
    • 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     PID/Program name   
tcp      0     0   prolin1:1521  prolin1:33303 ESTABLISHED 1327/oraclePROPRD1  
tcp      0     0   prolin1:1521  applin1:51324 ESTABLISHED 13827/oraclePROPRD1 
tcp      0     0   prolin1:1521  prolin1:33298 ESTABLISHED 32695/tnslsnr       
tcp      0     0   prolin1:1521  prolin1:32544 ESTABLISHED 15251/oracle+ASM    
tcp      0     0   prolin1:1521  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       Genmask          Flags  MSS Window irtt Iface
10.20.191.0   *             255.255.255.128  U       0   0       0  bond0
172.22.13.0   *             255.255.255.0    U       0   0       0  eth9
169.254.0.0   *             255.255.0.0      U       0   0       0  eth9
default       10.20.191.1   0.0.0.0          UG      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<<- 10.14.1.58="" 124934="" 141.146.8.66="" 148.87.1.20="" 148.87.112.100="" 199.7.68.1="" 199.7.69.1="" 1="" 2008="" 204.74.108.1="" 204.74.109.1="" 204.74.114.1="" 204.74.115.1="" 22:05:56="" 29="" 300="" 3230="" 328="" 46043="" 62512="" 8="" 97="" a="" additional:="" additional="" answer:="" answer="" authority:="" authority="" dec="" flags:="" id:="" in="" mon="" msec="" msg="" noerror="" ns1.oracle.com.="" ns4.oracle.com.="" ns="" opcode:="" oracle.com.="" pre="" qr="" query:="" query="" question="" ra="" rcvd:="" rd="" section:="" server:="" size="" status:="" time:="" u-ns1.oracle.com.="" u-ns2.oracle.com.="" u-ns3.oracle.com.="" u-ns4.oracle.com.="" u-ns5.oracle.com.="" u-ns6.oracle.com.="" when:="">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,   45 users,  load average: 4.45,  5.18, 5.38
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   pts/2        Jan  8 15:57  (10.14.105.139)
oracle   pts/3        Jan  8 15:57  (10.14.105.139)
root     pts/1        Dec 26 13:42  (:0.0)
root     :0           Oct 23 15:32
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     LINE         TIME         COMMENT
oracle   pts/2        Jan  8 15:57  (10.14.105.139)
oracle   pts/3        Jan  8 15:57  (10.14.105.139)
root     pts/1        Dec 26  13:42 (:0.0)
root     :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/ en donde 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  oracle oracle root root  
                              
… and so on for  45 names
# users=45
                            
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         TIME          IDLE          PID COMMENT
oracle   pts/2        Jan  8 15:57   .          18127 (10.14.105.139)
oracle   pts/3        Jan  8 15:57  00:26       18127 (10.14.105.139)
root     pts/1        Dec 26 13:42   old         6451 (:0.0)
root     :0           Oct 23 15:32    ?         24215
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,  load average: 3.35,  3.08, 2.86
# who -b
         system boot   Mar  7 22:58
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         TIME         IDLE          PID COMMENT
LOGIN    tty1         Feb 15  13:32              4081 id=1
LOGIN    tty6         Feb 15  13:32              4254 id=6
Para descubrir las terminales del usuario que ya no están en uso, utilice la opción -d:
# who -dH
NAME     LINE         TIME     IDLE          PID COMMENT  EXIT
                      Feb 15  13:31          489 id=si    term=0 exit=0
                      Feb 15  13:32         2870 id=l5    term=0 exit=0
         pts/1        Oct 10  14:53        31869 id=ts/1  term=0 exit=0
         pts/4        Jan 11  00:20        22155 id=ts/4  term=0 exit=0
         pts/3        Jun 29  16:01            0 id=/3    term=0 exit=0
         pts/2         Oct 4  22:35         8371 id=/2    term=0 exit=0
         pts/5        Dec 30  03:15         5026 id=ts/5  term=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                PID COMMENT
                      Feb 15 13:32       4083 id=2
                      Feb 15 13:32       4090 id=3
                      Feb 15 13:32       4166 id=4
                      Feb 15 13:32       4174 id=5
                      Feb 15 13:32       4255 id=x
                      Oct  4 23:14      13754 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       LINE          TIME         COMMENT
oracle   + pts/2        Jan 11 12:08  (10.23.32.10)
oracle   + pts/3        Jan 11 12:08  (10.23.32.10)
oracle   - pts/4        Jan 11 12:08  (10.23.32.10)
root     + pts/1        Dec 26 13:42  (:0.0)
root     ? :0           Oct 23 15:32
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         TIME         IDLE          PID COMMENT
         run-level 5  Feb 15  13:31                   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         IDLE          PID COMMENT  EXIT
                       Feb 15 13:31               489 id=si    term=0 exit=0
          system boot  Feb 15 13:31
          run-level 5  Feb 15 13:31                   last=S
                       Feb 15 13:32              2870 id=l5    term=0 exit=0
LOGIN     tty1         Feb 15 13:32              4081 id=1
                       Feb 15 13:32              4083 id=2
                       Feb 15 13:32              4090 id=3
                       Feb 15 13:32              4166 id=4
                       Feb 15 13:32              4174 id=5
LOGIN     tty6         Feb 15 13:32              4254 id=6
                       Feb 15 13:32              4255 id=x
                       Oct  4 23:14             13754 id=h1
           pts/1       Oct 10 14:53             31869 id=ts/1  term=0 exit=0
oracle   + pts/2       Jan  8 15:57   .         18127 (10.14.105.139)
oracle   + pts/3       Jan  8 15:57  00:18      18127 (10.14.105.139)
           pts/4       Dec 30 03:15              5026 id=ts/4  term=0 exit=0
           pts/3       Jun 29 16:01                 0 id=/3    term=0 exit=0
root     + pts/1       Dec 26 13:42  old         6451 (:0.0)
           pts/2       Oct  4 22:35              8371 id=/2    term=0 exit=0
root     ? :0          Oct 23 15:32   ?         24215
           pts/5       Dec 30 03:15              5026 id=ts/5  term=0 exit=0
           pts/4       Dec 30 22:35                 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 

#
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          TIME         COMMENT
oracle   + pts/2        Jan 11 12:08 (10.23.32.10)
oracle   + pts/3        Jan 11 12:08 (10.23.32.10)
oracle   - pts/4        Jan 11 12:08 (10.23.32.10)
root     + pts/1        Dec 26 13:42 (:0.0)
root     ? :0           Oct 23 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   JCPU  PCPU WHAT
oracle pts/1  10.14.105.139  16:43  0.00s  0.06s 0.01s w
oracle pts/2  10.14.105.139  17:26  57.00s 3.17s 3.17s sqlplus   
as sysdba
                               
… and so  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  :0.0  26Dec08 13days 0.01s   0.01s bash
root  :0      -    23Oct08 ?xdm?  21:13m  1.81s  /usr/bin/gnome-session
La opción -h fue utilizada para ocultar el encabezado.

kill

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  
                              

                            
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    00:00:00 sqlplus
oracle    8768 23896  0 10:36 pts/2    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    00:00:00 sqlplus   as sysdba
oracle    9885 23896  0 10:41 pts/2    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    00:00:00 sqlplus   as sysdba
oracle   10144 23896  0 10:42 pts/2    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    00:00:00 sqlplus   as sysdba
oracle   10198 23896  0 10:43 pts/2    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       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     17) SIGCHLD
18) SIGCONT     19) SIGSTOP     20) SIGTSTP     21) SIGTTIN
22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO
30) SIGPWR      31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1
36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4  39) SIGRTMIN+5
40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8  43) SIGRTMIN+9
44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13
52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9
56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6  59) SIGRTMAX-5
60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2  63) SIGRTMAX-1
64) SIGRTMAX
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 ]  [ -a ] pid ...
       kill -l [ signal ]
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]   Terminated              sqlplus
[3]   Terminated              sqlplus
[4]   Terminated              sqlplus
[5]   Terminated              sqlplus
[6]   Terminated              sqlplus
[7]-  Terminated              sqlplus
[8]+  Terminated              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]         (1)   - bash built-in commands, see bash(1)
: [builtins]         (1)   - bash built-in commands, see bash(1)
[ [builtins]         (1)   - bash built-in commands, see bash(1)
alias [builtins]     (1)   - bash built-in commands, see bash(1)
bash [builtins]      (1)   - bash built-in commands, see bash(1)
bg [builtins]        (1)   - bash built-in commands, see 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  session '116,5784'
  2  /
 
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 =  'SH'
  8  );
SPID
------------------------
30986
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  '125,35447' immediate;
alter system disconnect session  '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) with signal 15
Killed sqlplus(26452) with signal 15
Killed sqlplus(26456) with signal 15
Killed sqlplus(26457) with signal 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) ? (y/n) n
Kill sqlplus(2555) ? (y/n) n
Kill sqlplus(2555) ? (y/n) y
Killed sqlplus(2555) 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)
digUna nueva versión de nslookup
ifconfigPara desplegar información en las interfaces de red
killPara finalizar un proceso específico
killallPara finalizar un proceso específico, un grupo de procesos y los nombres que coinciden con un patrón
mesgPara activar o desactivar la capacidad de los demás para desplegar algo en la terminal de uno.
netstatPara desplegar estadísticas y otras métricas sobre el uso de la interfaz de red
nslookupPara 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
talkPara establecer un sistema de Mensajería Instantánea entre dos usuarios para lograr una conversación en tiempo real
uptimePara saber por cuánto tiempo ha estado funcionando el sistema y conocer su carga promedio en 1, 5 y 15 minutos
wEs una combinación de uptime y who
wallPara desplegar texto en las terminales de todos los usuarios que han iniciado sesión
whoPara desplegar a todos los usuarios que han iniciado sesión en el sistema y para saber lo que están haciendo
writePara 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.

Lectura Adicional