###### ### ########## ###### ############ ##### # ######## ## ##### ###### ###### ###### ##### ########## ## ###### ############ ##### ##### ############ ##### ###### ########## ##### ##### ###### ####### ###### ####### ###### ########### ##### ######## ####### ### ##### Facultad de informática Universidad Nacional del Comahue Introducción a la terminal de `GNU+Linux` ========================================= Este documento (y si, un archivo de texto sigue siendo un documento aunque no tenga letras en negritas ni distintas tipografías) es un pequeño tutorial para poder empezar a utilizar la terminal de comandos de los sistemas tipo `UNIX`, y en particular la terminal virtual de `GNU+Linux` ejecutando `BASH`. Al final del documento hay una lista de enlaces, las referencias se marcan encerrando el nombre entre corchetes: [ejemplo!]. Consolas, terminales y ¿caparazones? ------------------------------------ ¿Qué es una consola? ~~~~~~~~~~~~~~~~~~~~ Las computadoras de tiempo compartido permitieron que varios usuarios ejecutaran programas sobre la misma computadora concurrentemente. Para poder interactuar con los programas interactivos cada computadora tenía una o más consolas de texto (también llamada terminal de texto). Las consolas de texto tienen tres componentes principales: un teclado, una salida de texto y la conexión a la computadora o mainframe. Al principio la salida de texto era solo una máquina de escribir (ver el enlace [teletipo!] al final del documento), pero luego se adaptaron pantallas de texto. ¿Qué es el shell? ~~~~~~~~~~~~~~~~~ Utilizando una consola se puede ejecutar gran variedad de programas, pero por lo general el primer programa que se ejecutará cuando nos conectamos a una computadora es un interprete de comandos. En los sistemas tipo `UNIX` normalmente este será [`BASH`!]. Al iniciar una nueva sesión de `BASH` la consola nos mostrará un mensaje de bienvenida y el *prompt*. El *prompt* es un fragmento de texto que nos indica que el interprete de comandos esta listo para leer nuestras ordenes, e incluye algunos datos que nos pueden ser de utilidad. En la mayoría de las computadoras (si el usuario no ha cambiado la configuración) el *prompt* lucirá similar al siguiente: peperina@host:~$ Los primeros dos valores indican el usuario y nombre de la computadora, entre los símbolos `:` y `$` se encuentra el directorio actual. Los comandos que el usuario ingrese se escribirán luego del `$`, terminando con la tecla `ENTER` para ejecutarlo. En los manuales y tutoriales de `BASH` es normal que se utilice únicamente el símbolo `$` para indicar todo el *prompt*. Las líneas precedidas por `$` son los comandos que el usuario debe ingresar, y el resto son resultado de la ejecución del programa. $ ls apuntesIC.txt fondo.png teoría descargas prácticos $ date Thu Jan 1 00:00:00 -03 1970 $ ¿Qué es una terminal virtual? ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Cuando la computadora a la que uno se quiere conectar es la misma que se esta usando, resulta poco practico ir a un museo de historia para pedirles prestada una consola de texto. Para solucionar este problema, existen versiones de software de las consolas, llamadas terminales virtuales. En los laboratorios se puede abrir una nueva consola virtual accediendo al menú principal (arriba a la izquierda), yendo al submenu "Herramienta del sistema" y seleccionando "terminal de GNOME". Si se quiere una experiencia más cercana a las consolas de texto históricas, pueden presionar `ALT+CRL+F2` (con `ALT+F7` se retorna a la terminal gráfica). Entrada, salida y parámetros ---------------------------- La mayoría de los programas de línea de comandos se comunican con el usuario de tres maneras distintas: antes de la ejecución el usuario puede definir los parámetros de ejecución, durante la ejecución el programa lee de la entrada estándar y escribe a la salida estándar: - Los parámetros son establecidos antes de comenzar la ejecución del programa. Para llamar a un programa con unos parámetros específicos en `BASH` se debe utilizar la siguiente sintaxis: nombre_del_programa parámetro_1 parámetro_2 ... parámetro_N Es importante que los parámetros y el nombre del programa estén separados por espacios, no es lo mismo `gzip -k -9` que `gzip -k-9` ni `gzip-k -9`. En algunos casos el orden de los parámetros no es importante, mientras que en otros si. Si un parámetro contiene espacios, se necesita encerrarlo entre comillas simples o dobles, o "escapar" el espacio anteponiéndole una barra invertida `\`: cat "archivo con espacios.txt" rm archivo\ con\ espacios.txt - La *entrada estándar* clásica es el teclado. Lo que usuario escribe con el teclado, el programa lo puede leer en la entrada estándar. - La *salida estándar* clásica es la pantalla. Lo que el programa escribe por salida estándar se muestra por pantalla como texto en la terminal. Con la ayuda de las tuberías de `UNIX` (llamadas comúnmente *pipes*, y representadas por el carácter `|`), se puede redirigir la salida estándar de un comando a la entrada estándar de otro. Si ejecutamos `prog1 | prog2` cuando el proceso de `prog1` intente escribir a su salida estándar el | tomara el texto y lo irá transcribiendo a la entrada estándar del proceso de `prog2`. Por ejemplo, el comando `ls -1` nos lista los archivos de un directorio, cada uno por linea, y el comando `wc -l` cuenta la cantidad de lineas. Si se combinan con un pipe: `ls -1 | wc -l` obtendremos la cantidad de archivos en un directorio. Existen otros medios de comunicación entre procesos y el usuario, pero por ahora estos son más que suficiente para comenzar a utilizar la terminal. Posición dentro del árbol de directorios ---------------------------------------- En los sistemas `UNIX` cada proceso se ejecuta dentro de un directorio especifico dentro del árbol de directorios. Cuando se abre una nueva terminal, el interprete de comandos `BASH` iniciará ejecutando en el directorio `$HOME` del usuario (normalmente en `/home/USUARIO/`, y abreviado con el símbolo `~`). Se puede ver el directorio actual con el comando `pwd`, y se puede cambiar de directorios con el comando `cd dirección_directorio`. Al lanzar un nuevo proceso, *hereda* del padre (en este caso `BASH`) el directorio actual. Para ver los archivos que se encuentran dentro del directorio actual se puede utilizar el comando `ls`. Si en el `$HOME` del usuario "peperina" hay un directorio llamado `ic`, y dentro de este un archivo llamado `apuntesIC.txt` al ejecutar la siguiente secuencia de comandos veremos como resultado: $ pwd /home/peperina/ $ ls ic $ cd ic $ pwd /home/peperina/ic $ ls apuntesIC.txt Normalmente un usuario solo tiene permisos de escritura en dos lugares en todo el árbol de directorios: dentro su directorio `$HOME` y subdirectorios, y dentro del directorio `/tmp`. Una causa probable del fallo de un comando es que se este intentando crear o modificar un archivo fuera de estos directorios. _________________________________________ / Si un comando falla: verifica estar en \ | el directorio correcto con `pwd`, y que | | los archivos necesarios estén dentro | \ con `ls`. / ----------------------------------------- \ ^__^ \ (oo)\_______ (__)\ )\/\ ||----w | || || MAYÚSCULAS y minúsculas ----------------------- Los sistemas tipo `UNIX` distinguen entre mayúsculas y minúsculas, tanto en los comandos y sus parámetros, como en los nombres de directorios y archivos. Es posible tener dentro de un mismo directorio un archivo llamado `ice` y otro llamado `ICE`, el comando `ls` con el parámetro `-a` tiene un comportamiento distinto a si se invoca con el parámetro `-A`. Que no haya noticias, son buenas noticias ----------------------------------------- Hay comandos que realizan cambios en el entorno sin mostrar texto en la pantalla, a menos que haya un error. Si al ejecutar un comando no se muestra nada por pantalla, antes de asustarse hay que analizar cual es la función del comando. Comandos útiles y trucos ------------------------ Los siguientes comandos son los mínimos necesarios para poder comenzar a utilizar la terminal de `GNU+Linux`. Movimiento dentro del árbol de directorios ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - `pwd` imprime la ruta hasta el directorio actual: - `cd nombre_dir` nos movemos hacia el directorio `nombre_dir`. Se pueden utilizar direcciones relativas o absolutas. - `cd ..` nos movemos del directorio actual a su directorio padre. Es decir, de `/home/peperina/ic/` nos movemos a `/home/peperina`. - `cd` sin parámetros, retorna al `$HOME` - `mkdir nombre_directorio` crea un nuevo directorio dentro del directorio actual. Listar y mostrar archivos ~~~~~~~~~~~~~~~~~~~~~~~~~ - `ls` lista los archivos en el directorio actual. - `cat archivo` imprime por pantalla todo el contenido de `archivo`. - `more archivo` nos muestra por pantalla el contenido de `archivo`, pero de a una pantalla por vez. Avanzamos una linea con `ENTER` y toda una pantalla con `ESPACIO`. Salimos con `q`. - `less archivo` nos muestra por pantalla el contenido de `archivo`, pero podemos movernos hacia arriba o abajo utilizando las flechas, con `ESPACIO` se avanza una pantalla completa y se sale pulsando `q`. - `file archivo` nos da información sobre el tipo del archivo. - `see archivo` consulta una base de datos para abrir el archivo con el programa que corresponda. Editar archivos ~~~~~~~~~~~~~~~ - `nano archivo` permite editar un archivo de texto. Los controles se muestran en la parte inferior de la pantalla (`^N` quiere decir presionar `CTRL+n`). El gran manual ~~~~~~~~~~~~~~ - `man nombre_comando` muestra un manual sobre el comando o función. Los controles son los mismos que los de `less` (nos movemos con las flechas, salimos con `q`). - `man -a nombre_comando` si existen varios comandos o funciones con el mismo nombre, abre el manual para cada uno de ellos de forma sucesiva. - `apropos cadena` busca que entradas del manual tienen una contienen el texto `cadena`. El historial ~~~~~~~~~~~~ - `history` imprime todos los comandos utilizados. - `history | less` utilizamos `less` para leer la lista de comandos. - Con las flechas `arriba` y `abajo` del teclado podemos recorrer el historial de comandos tipeados. Otros trucos ~~~~~~~~~~~~ - Con la tecla `TAB` podemos autocompletar. Si tenemos un archivo llamado `apuntes.txt` basta con tipear `nano apun` y presionar `TAB` para que `BASH` complete el nombre del archivo (si es el único en el directorio que comience con "apun"). - Presionar `CRTL-C` no copia, sino que termina el proceso actual. - Presionar `CRTL-Z` no deshace, sino que _"minimiza"_ el proceso. Para volver a traerlo, ejecutar el comando `fg`. Enlaces: ======== [teletipo]: https://www.youtube.com/watch?v=-Ul-f3hPJQM "Conectándose a `GNU+Linux` con una teletipo" [nethack]: ssh://nethack@alt.org [bash]: https://es.wikipedia.org/wiki/Bash "Bash (wikipedia)"