Curso de Linux en español 3/60 - Comandos y Error Estandar
comandos shell linux y error estandar

Curso de Linux en español 3/60 - Comandos Básicos y Salida Estandar

Esta es la tercera entrega del curso de Linux, en esta entrega vamos a tratar los siguientes temas:

  1. Interface de shell.
  2. Comandos básicos para manejar la interface de Shell.
  3. La entrada estándar.
  4. La salida estándar.
  5. El error estándar.
  6. CLI Command Line Interfase (Interface de Línea de Comandos)

Interface de shell

Ahora vamos a entrar en materia, primero vamos a ver cómo entramos a la interface básica de usuario "la CLI" (interface de comandos). Ahí vamos a ver los comandos básicos para poder desenvolvernos, luego vamos a ver cómo se interactúa con la entrada y salida del flujo de datos de shell , comencemos.

Primero que tenemos que hacer es ingresar en nuestro sistema.

Eso lo hacemos por medio de la consola de ingreso en el sistema operativo en este caso vamos a utilizar el sistema operativo Linux Ubuntu nos da una pantalla que se llama login esta es la consola por la que nosotros podemos ingresar al sistema operativo de forma remota por SSH o por telnet.

Este login nos muestra la versión del sistema operativo que estamos corriendo, en qué terminal la estamos corriendo y luego nos muestra el nombre de la máquina, (login: ) a eso le vamos a llamar prompt de login, porque es donde nosotros vamos a escribir nuestro usuario y contraseña para poder ingresar. También vemos una raya titilante a la que vamos a llamar cursor.

Una vez ingresamos nos vamos a la información como la última vez que ingresamos, la versión del sistema operativo y algunos paquetes que tenemos que actualizar (eso es diferente en las diferentes distribuciones de Linux), este caso estamos utilizando Ubuntu.

Comandos básicos para manejar la interface de Shell

¿Que usuario estamos utilizando?

Lo primero que tenemos que hacer es saber quiénes somos, cuál es nuestro usuario, esto lo hacemos con un comando llamado whoami entonces vemos que el usuario de este ejemplo es: fox

¿Donde Estamos?

Acto seguido queremos ver dónde estamos parados en el sistema, es decir en el sistema de archivos del sistema operativo donde estamos ubicados eso lo podemos saber con el comando pwd, aquí vemos que estamos parados en /home/fox dentro del sistema de archivos de nuestro sistema operativo Linux.

¿Que versión de Linux estamos usando?

Una vez sabemos dónde estamos parados queremos saber qué sistema operativo estamos corriendo, para eso existe un comando llamado uname. el comando uname nos va a mostrar el sistema operativo que corremos en este caso el sistema operativo es Linux.

Adicional a esto tenemos el parámetro -a, el parámetro -a nos permite ver el sistema operativo en el que estamos corriendo con toda la información de el incluyendo, el host donde está corriendo, la fecha de compilación y la plataforma de arquitectura de hardware para la cual fue compilado en este caso es a AMD 64 por qué es un procesador de 64 bits.

Este comando es estándar de Unix como los otros comandos que veremos sirven tanto en Linux como en otras versiones de Unix, entonces nos provee una ventaja porque al aprender el manejo básico del sistema operativo basado en Linux también estamos aprendiendo otros sistemas operativos y su manejo básico.

Aquí tenemos por ejemplo el sistema operativo HURD qué es el sistema operativo de GNU en el cual trabaja Debian esta es la versión 3.0.

Este por ejemplo es MINIX qué es el sistema operativo que inspiró a Linux Torvalds a desarrollar el sistema operativo Linux.

terminal minix

Aquí tenemos OpenBSD que es un UNIX BSD libre, aquí tenemos un compañero de él que es NetBSD es otro y UNIX BSD libre y tenemos el tercer hermano de esta familia que es FreeBSD que también es un UNIX libre.

terminal OpenBSD

Acá tenemos al sistema operativo INDIANA que es un sistema operativo basado en el antiguo Solaris 11 que su kernel es la versión 5.11.

terminal indiana

Por último tenemos el sistema operativo MacOS X en su versión LION que corre como vemos el kernel Darwin. Este kernel como ya habíamos visto en la primera entrega de este curso, es el kernel del sistema operativo de Apple esta es su versión 11.4.2.

consola MAC OS Drawin

Bueno volviendo a nuestro Linux ya sabemos, quiénes somos, en dónde estamos y en qué sistema operativo estamos corriendo, pero ahora queremos saber lo siguiente:

¿Cuánto espacio hay en el disco duro?

Esto lo haremos con el comando df el comando, df, nos muestra cuánto espacio en total tiene la partición, cuánto espacio ocupado y cuánto espacio libre posee, además de eso nos muestra el porcentaje de ocupación y donde está montado. Entonces con ese comando podemos darnos cuenta cuál es el estado de nuestro dispositivo de almacenamiento montado.

El comando df tiene un parámetro menos llamado -h, el parámetro - h es muy importante porque es utilizado en otros comandos de la implementación GNU porque no se muestra el tamaño de la información en Byte, Kilobytes, Megabytes, Gigabytes y Terabyte.

Otro comando muy útil para saber los recursos de nuestra máquina es free nos permite saber cuánta memoria tenemos, entonces en la primera columna nos va a mostrar el total de la memoria, la memoria usada, la memoria libre, la memoria que se encuentra en buffer y en caché. También nos muestra memoria de intercambio su total, la memoria usada y la memoria libre, de la memoria de intercambio ya hablamos un poco en el capítulo 2 de este curso. Aquí también funciona el parámetro -h nos muestra en Byte, Kilobytes, Megabytes, Gigabytes y Terabyte.

El parámetro es -h por qué significa human-readable format, es decir formato legible al humano. Entonces podemos ver que con el parámetro -h nos muestra la información en un formato más entendible.

Comandos Echo y Cat

Otro comando importante es el comando echo. el comando echo nos regresa a la salida estándar de la shell lo que nosotros le pasemos como parámetro, es algo que te puede parecer algo tonto pero echo es uno de los comandos más usado dentro del scripting cuando nosotros hacemos programas para automatizar cosas dentro de nuestro sistema operativo.

También tenemos el comando cat qué significa concatenar este comando nos va a mostrar de una forma cruda la salida estándar de un archivo hacia la shell el cual nosotros especifiquemos como parámetro.

Bueno con esto tenemos lo mínimo para poder interactuar con nuestro sistema operativo, ahora vamos a ver algo muy importante el flujo de datos de la entrada estándar, la salida estándar y el error estándar.

Entrada, Salida y Error Estándar

Comprender el flujo de datos del shell es muy importante porque con esto podemos comprender cómo la información entra a la shell y sale de la Shell esto nos permite redirigir esa información para nuestro beneficio.

Tenemos como ejemplo el comando uname que de ahora y hasta que termine este tema vamos a utilizarlo como ejemplo, entonces una vez nosotros digitamos nuestro comando y damos enter, le estamos diciendo a la Shell que ejecute ese comando ese comando debe decirnos cuál es el sistema operativo que estamos corriendo en este caso es Linux.

¿Cómo podemos re-direccionar esa salida que nos está mostrando en la shell en la pantalla?

Bueno es muy sencillo lo hacemos con el símbolo > entonces colocamos: uname > y el archivo al que lo queremos enviar, en este caso es so.txt. Vemos con cat cuál es el contenido de so.txt y efectivamente nos muestra que redirigió la salida.

entrada, salida y error estandar

Esto es lo mismo hacerlo con 1> y el archivo, porque resulta que en la shell el flujo de datos está determinado por tres valores la entrada estándar que es 0, la salida estándar que es 1 y el error estándar que es 2 en este caso sería la salida estándar que se representa por el 1 entonces por eso nos da lo mismo colocar 1> y el archivo.

salida estandar de comandos linux

Pero resulta que cada vez que lo hagamos vamos a reemplazar el contenido del archivo, que hay si nosotros queremos acumular la información qué sacamos de la salida estándar, eso es muy fácil podemos colocar 1>> y vemos cómo va acumular línea a línea cada una de las salidas de los comandos que nosotros le hayamos indicado, si damos el parámetro -a entonces vemos que nos acumuló los que hizo con uname y luego los que hizo con uname -a.

uname salida estandar acumulada para comandos linux

La entrada estándar también puede ser redirigida por ejemplo al comando cat le podemos indicar que su entrada estándar es el resultado del archivo so.txt, entonces en ese caso nos muestra el contenido del archivo hacia la salida estándar.

El error estándar se comportan muy parecido cómo se comporta la salida estándar, nosotros le podemos pasar un parámetro por ejemplo: uname -y que no existe, entonces esto nos va a generar un error contrario. tenemos el parámetro -a que sí existe qué es el que nos muestra todos los datos del sistema operativo, entonces en este caso podemos redirigir uname -y pero no con el 1 sino con el 2 porque esta salida que nos generó el error no es salida estándar, no es presentada por el 1 es presentada por el 2 y esto se verá reflejado en el archivo qué queremos indicarlo por ejemplo el archivo error.

Entonces vemos que si hacemos cat al archivo error nos va a mostrar el archivo que error que acabamos de generar, de la misma forma también podemos acumular línea a línea estos mensajes de error para que no los muestre log.

¿Como combinar la salida estándar y el error estándar en un solo archivo?

Bueno es muy fácil, colocamos uname -a > log 2>&1 esto nos va a redirigir la salida de uname ya sea de error o salida estándar hacia el archivo log. Si nosotros queremos acumular línea a línea tanto la salida estándar como el error estándar pues hacemos lo mismo que los pasos anteriores simplemente colocamos >> quedando así uname -a >> log 2>&1 y éste nos va a ir acumulando tanto el error estándar como la salida estándar dentro del archivo indicado que en este caso es log.

La importancia a la que me refiero a la salida estándar no es solamente porque podemos dirigir lo que sale en pantalla hacia archivos, también lo podemos dirigir hacia dispositivos y desde dispositivos por ejemplo si yo quiero imprimir la salida de comando y uname -a hacia una impresora pues lo hago diciéndole cuál es el dispositivo de la impresora en la mayoría de los casos seria /dev/lp0.

También podemos redirigir la salida de la terminal hacia una terminal por ejemplo vamos a redirigirla hacia la misma terminal que estamos usando entonces utilizamos nuestro comando uname -a y lo redirigimos hacia la terminal que estamos corriendo en este caso pts/9 cuya ruta es /dev/pts/9 entonces vemos que la redirección del comando es efectiva hacia nuestra terminal, porque la redirigimos la salida estándar hacia esta terminal.

También la podemos redirigir hacia otro terminal por ejemplo hacia la consola allí la consola está corriendo en tty 1 entonces podemos redirigir uname –a y cambiar la terminal por /dev/tty1 entonces vemos que efectivamente nuestro comando uname -a su salida estándar fue redirigida no hacia la terminal que estamos utilizando sino hacia la terminal de la consola del sistema operativo.

Podemos redirigir desde un dispositivo hacia un archivo es el caso por ejemplo de /dev/zero qué es un generador de caracteres de Null.

Este se utiliza normalmente para limpiar dispositivos de bloque o para generar archivos que van a ser utilizados como imágenes de dispositivo de bloque, entonces podemos generar esos Null y redirigir hacia un archivo y hasta que le demos control c no va a parar de mandar esta salida hacia el archivo que nosotros queremos llenar de caracteres de Null .

En shell script es muy utilizado enviar la salida estándar y el error estándar hacia un lugar donde no moleste, ósea donde no cree un archivo y lo llene de datos, este es el caso de /dev/null entonces todo lo que nosotros enviamos ahi simplemente va desaparecer.

Como en el ejemplo.

Tuberia (Pipe)

Además de esto tenemos 2 herramientas adicionales para controlar el flujo de datos de la salida estándar, primero tenemos el pipe o tubería está representado por el carácter que es una raya (|) en inglés se llama pipe y éste nos permite tomar la salida estándar de un comando y colocarla como parámetro de entrada a otro comando. Volvemos al ejemplo nuestro comando uname -a y se lo pasamos como parámetro cat.

¿Cómo se lo estamos pasando?

Bueno la salida estándar del comando uname -a la estamos pasando a través del | al comando cat y por eso no le está mostrando en la salida estándar además de esto tenemos la utilidad xargs esta utilidad nos permite pasarle la salida estándar de un comando como parámetro de otro comando entonces vamos a hacer lo siguiente.

Vamos a redirigir la cadena “-a” hacia un archivo llamado param, nos aseguramos de que param contiene –a, luego damos cat param | xargs uname.

¿Qué quiere decir esto?

Esto significa que el comando cat va a leer el contenido del archivo param cuyo contenido es -a y lo va a pasar por medio de | a uname

¿Cómo sucede esto?

Bueno cat lee el archivo param luego se lo pasa por medio del | a xargs, axrgs le dice a uname   que lo que viene por medio del | es su parámetro, por eso se ejecuta como uname -a mostrándonos a la salida estándar lo que debería salir si solo se corriera con uname.

Bueno con esto llegamos al final de la tercera entrega de nuestro curso de Linux en el cual hemos aprendido de forma muy básica la interface de comando el de nuestra shell del sistema y hemos entendido el flujo de datos de la salida estándar la entrada estándar y el error estándar.

Diferido | Preguntas y respuestas del curso de Linux 1 al 3 de 60

2 comentarios

  1. Quisiera tener todo el curso sobre Linux, pero en texto. Osea, en PDF o WORD.

Comentar

Su dirección de correo electrónico no será publicada.Los campos necesarios están marcados *

*

9 Compartir
Compartir9
Twittear
Compartir
+1