# Tutorial de la Terminal de Linux _Esta es la segunda parte de la charla sobre la terminal de linux, dada por Gustavo Castellanos y German Robayo, Coordinadores de Información y Tecnología del Centro de Estudiantes de Ingeniería de la Computación 2017-2018 de la Universidad Simón Bolívar._ ![](https://steemitimages.com/DQmenTDoGndXfvDLHDD17tdvDN1GLigTpoJJvCEXnjnRAgi/image.png) ## Resumen de la Primera Parte En [este](https://steemit.com/spanish/@gustavoaca1997/tutorial-de-la-terminal-de-linux) artículo escrito por mi companero @gustavoaca1997 se da un resumen de la primera parte de la charla sobre la terminal de Linux dictada a los estudiantes de la Universidad Simón Bolivar (USB). En éste se encuentran los siguientes tópicos: * Flujos estándares. `stdout`, `stdin`, `stderr`. * Comandos basicos para manipulacion de ficheros: * `ls` * `cd` * `man` _el más importante de todos_ * `pwd` * `mkdir` * `rm` * `cp` * `mv` * Direcciones de archivos absolutas y relativas. ## Qué hablaremos En este artículo hablaremos sobre lo siguiente: * Control de flujo. * Comandos intermedios. * Procesos. * Condicionales. ## Control de flujo Recordemos los tres flujos estándares: `stdout`, `stdin`y `stderr`. Habíamos mencionado que Linux trata a estos como "ficheros". ¿Cómo manejamos el contenido de estos ficheros? La terminal provee operadores para ello. ### > _¿Cómo se llama?_ Yo le digo pollito, sin razón alguna. _¿Cómo se usa?_ ```bash $ pwd /home/user/charla/ $ ls a charla1 charla2 a.cpp b.c sample.py $ echo "Todo bien?" > nuevoArchivo.txt $ ls a charla1 charla2 a.cpp b.c sample.py nuevoArchivo.txt ``` _¿Qué hace?_ Transfiere el `stdout` del programa del lado izquierdo y lo guarda en el archivo que se coloque en la derecha. NOTA: Reemplaza el contenido del archivo. ```bash $ cat nuevoArchivo.txt Todo bien? ``` ### < _¿Cómo se llama?_ Yo le digo _menor que_. _¿Cómo se usa?_ Tenemos un sencillo script de python que lee vía `stdin` y luego imprime lo leído en mayúsculas. ```bash $ ls a charla1 charla2 a.cpp b.c sample.py nuevoArchivo.txt $ cat sample.py x = input() print(x.upper()) $ cat nuevoArchivo.txt Todo bien? $ python3 sample.py < nuevoArchivo.txt TODO BIEN? ``` _¿Qué hace?_ Convierte el contenido del archivo de la derecha en `stdin` para el comando de la izquierda. Permite hacer combinaciones de comandos muy elegantes e interesantes. ```bash $ python3 sample.py < nuevoArchivo.txt > out.txt $ cat out.txt TODO BIEN? ``` Aqui hicimos uso del `>` para capturar el `stdout` del comando y guardarlo en out.txt. ### >> _¿Cómo se llama?_ Yo le digo doble pollito. _¿Cómo se usa?_ Igual que el `>` _¿Qué hace?_ Funciona igual que el `>`, pero la diferencia es que este anade contenido al final, en vez de sobreescribirlo. ### << _¿Cómo se llama?_ Yo le digo doble menor igual. _¿Cómo se usa?_ Igual que el `<` _¿Qué hace?_ Este es interesante. Permite recibir el input como un _here-document_ ¿Qué significa esto? Mas facil explicarlo con un ejemplo: ```bash $ cat << EOF > texto.txt Esto esta escrito por el teclado Puedo seguir escribiendo hasta que escriba EOF eof no, EOF EOF con mas cosas no, solo EOF EOF # output Esto esta escrito por el teclado Puedo seguir escribiendo hasta que escriba EOF eof no, EOF EOF con mas cosas no, solo EOF ``` _¿Qué paso exactamente?_ Cuando usamos `<<`, el intérprete leerá nuestro input (`stdin`) hasta que se escriba `EOF` (el lado izquierdo). Nótese que no es necesario restringirse a `EOF`, puedo usar cualquier cosa. ```bash $ cat << EMPANADAS > texto.txt Muchas empanadas no le hacen daño a nadie. texto texto empanadas EMPANADAS DE CAZÓN EMPANADAS # output Muchas empanadas no le hacen daño a nadie. texto texto empanadas EMPANADAS DE CAZÓN ``` Hasta el momento hemos visto operadores que trabajan con archivos. ¿Cómo manejo los flujos generados por los programas? ### `|` _¿Cómo se llama?_ Yo le digo pipe, como una tubería, ya verán por que. _¿Cómo se usa?_ Seguimos con nuestro sencillo script de python. ```bash $ echo 'empanadas' | python3 sample.py EMPANADAS ``` _¿Qué hace?_ Transfiere el `stdout` del comando de la izquierda y lo transforma como `stdin` del de la derecha. Funciona como una tuberia, por eso el nombre. Esto permite generar combinaciones de comandos muy interesantes (ejemplos más abajo). ## Comandos intermedios Algo en común que tienen todos los comandos ya expuestos (a excepción de `cat` y otros mas), es que todo su input es pasado mediante argumentos, es decir, si hacemos: ```bash $ ls a charla1 charla2 a.cpp b.c sample.py nuevoArchivo.txt $ ls charla1 # cosas random, o nada posiblemente. $ echo charla1 charla1 $ echo charla1 | ls a charla1 charla2 a.cpp b.c sample.py nuevoArchivo.txt ``` _¿Qué sucedió exactamente?_ `|` Redirige `stdout` en `stdin`, pero `ls` no recibe argumentos via `stdin`, lo tienes que colocar a mano. A continuación, veremos muchos comandos que si aceptan `stdin` como argumentos y otros que te permiten hacer que comandos como `ls` puedan recibir `stdin`. ### `tail` ¿Qué hace? Recibe datos tanto por argumentos como por `stdin`. En ambos casos, muestra las últimas 10 líneas de los datos. ```bash # texto20lineas.txt tiene los numeros del 1 al 20 uno en cada linea. $ cat texto20lineas.txt 1 2 3 4 5 ... 19 20 $ cat texto20lineas.txt | tail 11 12 13 14 15 16 17 18 19 20 $ tail texto20lineas.txt 11 12 13 14 15 16 17 18 19 20 ``` Se le puede pasar como opcion `-n` usando como `n` cualquier numero, mostrará las últimas `n` líneas del archivo. ### `head` Hace exactamente lo mismo que `tail`, pero muestra las primeras 10 líneas, no las últimas. ### `less` Para explicar este archivo vamos a entrar en la siguiente situación. Supongamos que tenemos un archivo que tiene 1000 líneas aproximadamente (un código largo, por ejemplo). Si ejecutamos `cat archivolargo.txt` no podremos leerlo facílmente, pues nos mostrará todo el output. Si en vez ejecutamos `less archivolargo.txt` nos mostrará una especie de interfaz, en la que podremos ver nuestro archivo poco a poco subiendo con `k` y bajando con `j`. Podemos buscar tecleando `/patron_de_búsqueda` y bajar hasta el final presionando `G`. `less` tambien lee via `stdin`. ### `grep` Este es de mis comandos favoritos y mas útiles. Es muy poderoso, aunque muy poco comprendido. `grep` busca patrones en los archivos o en el `stdin` que le mandes e imprime, al `stdin`, las líneas que hagan match. Veamos un ejemplo: ```bash $ cat texto.txt El terminal es interesante ¿Cómo te llamas? Tu nombre suena interesante... # Cada 'interesante', dependiendo de la terminal, estará resaltado de algun # color reflejando match. $ grep interesante texto.txt El terminal es interesante Tu nombre suena interesante... ``` Los patrones que puedes usar son [expresiones regulares](), algo de lo que hablaré en un próximo artículo. Le podemos pasar más opciones, como por ejemplo: * `-v`: Invierte el sentido de matching. * `-E`: Permite el uso de [expresiones regulares extendidas]() Recuerda que si quieres ver mas información sobre este y cualquier otro comando, puedes usar el manual, `man`. ### `wc` Este comando, aunque tiene un nombre raro (sí, sé lo qué estas pensando), te da la siguiente información sobre los argumentos que le pases o el `stdin` que recibe: * Número de caracteres `\n`, esto indica cuantas líneas tiene el archivo. * Número de bytes. En la computadora, cada caracter ocupa un byte en memoria (si no son unicode), así que el número de bytes de un archivo es equivalente al número de caracteres que posee. * Número de palabras. Ejemplo: ```bash $ cat texto.txt El terminal es interesante ¿Cómo te llamas? Tu nombre suena interesante... $ wc texto.txt 3 11 77 ``` El primer número es el numero de líneas, el segundo el número de palabras y el tercero de bytes. ### `chmod` Antes de explicar qué hace este comando, voy a dar una muy breve explicación sobre los modos en los ficheros de linux. Existen 3 tipos de individuos en un sistema operativo linux: * Usuario: Con esto linux se refiere a ti, el que esta haciendo uso del terminal y el que tiene cuenta en la maquina. * Grupo: En linux, podemos organizar los usuarios en grupos lo que nos permite poder administrar la información de una manera eficiente. * Otros: Son el conjunto de usuarios menos tu. Ahora, sabiendo esta información, existen 3 permisos que se le pueden otorgar a los archivos sobre cierto tipo de individuos. * Escritura: Va directamente asociado a quienes pueden modificar el archivo, sea sobreescribiéndolo, modificando o añadiendo líneas. * Lectura: ¿Quienes pueden leer el archivo? Los permisos de lectura son para eso, restringir que personas pueden leerlo. * Ejecución: ¿Se puede ejecutar? ¿Quienes pueden ejecutarlo? Ahora, sabiendo esto, veamos qué hace chmod y cómo usarlo. ```bash $ ls a a.cpp b c guardado hola.txt sample.py sample.txt test test2.py test2.txt test.py test.txt $ ls -l # Investigar que hace -l, man ls total 64 -rwxrwxr-x 1 username username 9168 ene 18 14:24 a -rw-rw-r-- 1 username username 112 ene 18 14:24 a.cpp -rwxrwxr-x 1 username username 9168 ene 18 14:24 b -rw-rw-r-- 1 username username 0 ene 18 14:24 c -rw-rw-r-- 1 username username 16 ene 18 14:44 guardado -rw-rw-r-- 1 username username 5 ene 18 14:54 hola.txt -rw-rw-r-- 1 username username 22 ene 18 13:51 sample.py -rw-rw-r-- 1 username username 13 ene 18 14:34 sample.txt drwxrwxr-x 2 username username 4096 ene 18 14:26 test -rw-rw-r-- 1 username username 73 ene 18 15:08 test2.py -rw-rw-r-- 1 username username 26 ene 18 15:12 test2.txt -rw-rw-r-- 1 username username 30 ene 18 14:56 test.py -rw-rw-r-- 1 username username 18 ene 18 14:57 test.txt ``` Observen la primera columna, tiene un formato raro. Consiste de una palabra de 10 caracteres donde el primer caractér indica si es un directorio, y los otros nueve son tripletas de `r`,`w` y `x`. La primera tripleta es respecto al usuario, la segunda respecto al grupo y la tercera a los otros. La `r` indica permisos de lectura, la `w` de escritura y la `x` de ejecución. Por ejemplo, el archivo `a.cpp` tiene permisos de lectura para todo el mundo pero nada mas pueden modificarlos el usuario actual (que no necesariamente es `username`) y el grupo `username` (el grupo está en la tercera columna). Supongamos que por alguna razón necesito agregar permisos de ejecución para todos los usuarios en el archivo `a.cpp`. Puedo ejecutar: ```bash $ chmod +x a.cpp $ ls -l a.cpp -rwxrwxr-x 1 username username 112 ene 18 14:24 a.cpp # ^ ^ ^ Se añadieron los permisos para todos. ``` Ahora queremos quitarselos ```bash $ chmod -x a.cpp $ ls -l a.cpp -rw-rw-r-- 1 username username 112 ene 18 14:24 a.cpp # ^ ^ ^ Se eliminaron los permisos para todos. ``` Solo quiero que el usuario actual tenga permisos de ejecución ```bash # la 'u' se refiere al usuario actual, si el usuario que lo ejecuta no es el dueño # del archivo lanzará un error. $ chmod u+x a.cpp $ ls -l a.cpp -rwxrw-r-- 1 username username 112 ene 18 14:24 a.cpp # ^ Se añadio el permiso de ejecución los permisos para todos. ``` Solo quiero que los demás tengan solamente permiso de escritura ```bash # la 'o' se refiere a los otros usuarios $ chmod o=w a.cpp $ ls -l a.cpp -rwxrw--w- 1 username username 112 ene 18 14:24 a.cpp # ^ SOLAMENTE permisos de escritura ``` Si quiero que quiero que el grupo tenga solo permisos de lectura, añadir al usuario de ejecución y quitarle todos los permisos a los otros usuarios ```bash # La 'g' se refiere al grupo del archivo $ chmod g=r,u+x,o-rwx a.cpp $ ls -l a.cpp -rwxr----- 1 username username 112 ene 18 14:24 a.cpp* ``` Así que, aunque no lo mencioné, `chmod` sirve para modificar permisos de ficheros. ### `xargs` Este permite que comandos que no reciben nada via stdin como `ls` puedan hacerlo. `xargs` recibe via `stdin` y se lo coloca como argumentos a su argumento. Ejemplo: ```bash $ ls -1 *.txt # -1 te coloca todo en una sola columna, * es el wildcard. hola.txt sample.txt test2.txt test.txt $ ls -1 *.txt | rm # Arroja error por que rm recibe argumentos, no `stdin` rm: falta un operando Pruebe 'rm --help' para más información. $ ls -1 *.txt | xargs rm $ ls -1 *.txt # Arroja error por que no hay archivos .txt ls: no se puede acceder a '*.txt': No existe el archivo o el directorio ``` ## Procesos Hasta el momento hemos hecho abuso de la palabra programa cuando en realidad hay que hacer una diferencia notoria: * Un **programa** es un archivo que contiene instrucciones que leera y ejecutar el computador. Ejemplo: Scripts de python, programas en C, C++, binarios. * Un **proceso** es cuando el sistema operativo le asigna recursos suficientes para que se pueda llevar acabo la ejecución de un programa. Sabiendo esto, podemos concluir que un comando seria un programa y su ejecución un proceso. ¿Para qué nos interesa esto? Linux es un sistema operativo multiprocesos. Nos permite ejecutar varios procesos a la vez. ¿Cómo vemos los procesos que se están ejecutando? ### `ps` Este comando lista los procesos que se estan ejecutando en la terminal actual con cierta información sobre cada uno. ```bash $ ps PID TTY TIME CMD 2034 pts/0 00:00:00 bash 9310 pts/0 00:00:00 ps ``` Podemos observar 3 columnas. La primera es el PID, que significa _Process ID_, cada proceso tiene un número único que lo identifica. El TTY es la terminal de donde se esta ejecutando, `pts/0`. La columna TIME indica la cantidad de tiempo que ha usado el cpu para la ejecución de ese comando. Dirán: > ¿Porqué si el `bash` se lleva ejecutando desde que abrí la terminal dice 00:00:00? Aquí viene el plotwist. Cuando ejecutas un comando, no mandas a ejecutar `bash`, mandas a ejecutar dicho comando. El `bash` no interfiere en nada en la ejecución del comando. La cuarta columna CMD indica el comando que se esta ejecutando en dicho proceso. ### `&` El ampersand en la línea de comandos tiene una función. Correr un proceso en segundo plano (background). Cuando ejecutamos un comando se ejecuta en primer plano (foreground) por defecto, lo que nos quita la posibilidad de ejecutar otro programa sino hasta que termine la ejecución de este. Si lo ejecutamos en segundo plano, podremos seguir usando la terminal sin ningún inconveniente. Ejemplo: ```bash $ comando_que_tarda_10_minutos # Toca esperar 10 minutos hasta que termine la ejecución # del programa $ comando_que_tarda_10_minutos & [1] 12313 $ # Tenemos disponibilidad de ejecutar cualquier otro programa. ``` El `[1]` indica el jobID y el numero de al lado es el process ID. Si ejecutamos `ps`: ```bash $ ps # EL TIME PUEDE SER DISTINTO PID TTY TIME CMD 2034 pts/0 00:00:00 bash 9310 pts/0 00:00:00 ps 12313 pts/0 00:00:30 comando_que_tarda_10_minutos ``` Ahí esta nuestro proceso, siendo ejecutado hasta que termine solo o le manden una *señal*. ### `kill` Permite mandar señales a procesos. Las señales que mas uso son: SIGKILL, SIGTERM. Ejemplo: ```bash $ ps PID TTY TIME CMD 2034 pts/0 00:00:00 bash 9310 pts/0 00:00:00 ps 12313 pts/0 00:00:30 comando_que_tarda_10_minutos $ kill -9 12313 # 9 es el codigo de la señal SIGKILL $ # presiona enter [1]+ Terminado (killed) comando_que_tarda_10_minutos $ ps PID TTY TIME CMD 2034 pts/0 00:00:00 bash 9310 pts/0 00:00:00 ps ``` ## Ejemplo de la vida real Supongamos que estamos escribiendo código en sublime y se quedó congelado, no responde. Podemos ver TODOS los procesos haciendo: ```bash $ ps -aux ... # monton de output ``` Demasiado output y nada útil a la vista. Usemos `grep` ```bash $ ps -aux | grep subl german 13084 11.5 1.2 988756 47788 ? Ssl 20:54 0:01 /opt/sublime_text/sublime_text german 13096 30.5 0.9 78332 36500 ? Dl 20:54 0:02 /opt/sublime_text/plugin_host 13084 german 13107 0.0 0.0 16760 972 pts/0 S+ 20:54 0:00 grep --color=auto subl ``` 3 procesos y uno es grep así que ese no puede ser. Ajuro deben ser los otros. Matemoslos: ```bash $ kill 13084 13107 ``` Sublime cierra exitosamente. ## Si llegaste hasta aquí Quiero agradecerte a ti, querido lector por haber leído este tutorial que he escrito junto con mi compañero @gustavoaca1997. Espero que te haya gustado y que te sirva de ayuda. Mantente pendiente de futuros tutoriales sobre este tipo de cosas. ¡Hasta la proxima!