Linea de comandos *nix

Algunos comandos de línea básicos para empezar con *NIX

Este es mi pequeño intento de hacer una referencia rápida de algunos de los comandos *NIX mas comunes.


man

Este comando sirve para desplegar en pantalla el "manual" de un comando dado. Por ejemplo, si escribimos:

$ man man

En la pantalla veremos para qué sirve el comando man. Para ver qué hace el comando "ls", podemos escribir:

$ man ls

Para salir de vuelta a la línea de comando, podemos escribir una "q".

info

Este comando nos despliega ayuda similar al comando "man"; simplemente el formato de la ayuda es distinta.

ls

Este comando nos despliega el contenido de la carpeta en la que nos encontramos actualmente.

Hay 2 opciones que vale la pena mencionar de este comando:

$ ls -l

Al usar la opción "-l" también nos mostrará información adicional de los archivos. Por ejemplo:

$ ls -l
total 4
-rw-r--r-- 1 roflo migrupo 0 Jun 26 13:18 prueba

Voy a explicar lo que nos dice empezando por la derecha.

  • prueba - es el nombre del archivo
  • Jun 26 13:18 - es la fecha en que se modificó por última vez este archivo.
  • 0 - Es el tamaño del archivo.
  • migrupo - Es el grupo al que pertenece este archivo.
  • roflo - Es el dueño del archivo
  • 1 - es el número de links que usa este archivo.
  • "-rw-r--r--" - Son las banderas del archivo. Los voy a explicar un poco:

El primer caracter suele indicar si el arcvhivo es un directorio o un link. En este caso, hay un "-" lo cual indica que es un archivo común. Nótese que en *Nix, los directorios son tratados como un tipo especial de archivo.

Los siguientes 3 caracteres son los permisos de lectura, escritura y ejecución del dueño del archivo. En este caso, "rw-" indica que sólo hay permiso de lectura y escritura. En caso de contar con los 3 tipos de permiso, diría "rwx".

Los siguientes 3 caracteres, al igual que lo explicado en el párrafo anterior, indica los permisos de lectura, escritura y ejecución del grupo al cual pertenece el archivo.

Finalmente, los últimos 3 caracteres indican los permisos del resto de usuarios que tienen acceso a la máquina.

Para modificar los permisos, se usa el comando chmod.

$ ls -a

Esta opción despliega también los archivos ocultos. Son ocultos todos los archivos que empiezan con un punto (".").

$ ls -a
. .. prueba

Aquí vemos 2 archivos especiales: "." y ".."

El primero es "sinónimo" del "directorio actual". El segundo es el nombre que recibe el directorio padre (el que contiene al actual).

Las banderas se pueden combinar; de tal manera que:

$ la -la
total 24
drwxrwxr-x 2 roflo migrupo 4096 Jun 26 13:23 .
drwxr-x--x 47 roflo migrupo 4096 Jun 26 13:23 ..
-rw-r--r-- 1 roflo migrupo 5 Jun 26 13:23 prueba

cd

Este comando nos sirve para cambiar de directorio.

$ cd abc

Esto cambiaría al directorio "abc".

$ cd ..

Nos cambia al directorio padre.

$ cd -

Nos cambia al directorio anterior.

pwd

Nos muestra el directorio actual.

$ pwd
/home/roflo/temp

whoami

Nos muestra nuestro nombre de usuario.

$ whoami
roflo

id

Nos da un poco más de información respecto a nuestra cuenta:

$ id
uid=1019(roflo) gid=1023(migrupo) groups=48(apache)

who

Nos dice quienes están actualmente conectados a esta máquina (y desde dónde están conectados).

$ who
root pts/1 Jun 20 02:01 (10.0.0.1)
roflo pts/2 Jun 26 13:13 (10.0.0.2)
juan pts/3 Jun 23 09:56 (10.0.0.3)

chmod

Este comando nos permite cambiar los permisos de un archivo.

Hay 3 formas simples de usar este comando:

$chmod -x archivo

Esto le quita permisos de ejecución a un archivo. También se podría usar "-r" para quitar permiso de lectura, "-w" para quitar permiso de escritura. Para agregar permisos, usamos "+r", "+w", y "+x".

$chmod g-x archivo

Esto le quita permisos de ejecución al grupo. También podemos modificar los permisos del dueño usando la letra "u" o del "resto del mundo" usando la letra "o" (ej: "u+w" para agregar permiso de escritura al dueño del archivo)

$chmod 740 archivo

Esto modifica cada bandera individualmente de la siguiente manera:

  • Lectura "r" = 4
  • Escritura "w" = 2
  • Ejecución "x" = 1

Entonces, tenemos en este ejemplo que que "rwx" = 7; "r--" = 4; "---" = 0. Entonces 740 se traduce en "rwxr-----".

Ojo: Para poder "entrar" a un directorio, este debe tener permisos de ejecución ("x").

uptime

Este comando nos indica cuánto tiempo ininterrumpido lleva funcionando la máquina, asi como en número de usuarios conectados y la carga promedio del procesador:

$ uptime
13:48:52 up 6 days, 4:26, 3 users, load average: 0.09, 0.16, 0.21

top

Este comando nos muestra los procesos que más procesador están consumiendo. Para salir de la pantalla, hay que oprimir "q".

cat

Este comando arroja a la pantalla el contenido de un archivo (típicamente de texto).

$ cat prueba
asdf

Para editar un archivo, es necesario usar un editor como "pico", "vi" o "emacs". Para los principiantes, es recomendable "pico" por su sencillez, pero no siempre está disponible.

grep

El comando grep analiza el texto a la entrada y regresa aquellas líneas que contengan la expresión que le damos.

Por ejemplo:

$ grep MAXVAL prueba.c
#define MAXVAL 100
for (i=1;i<=MAXVAL;i++){

En este ejemplo, grep nos regresó las líneas dentro de "prueba.c" donde encontramos la cadena "MAXVAL".

Este comando es especialmente útil usando el "pipe" ("|") de línea de comando. Poe ejemplo:

$ ls -l | grep 2006
-rw-rw-r-- 1 roflo migrupo 21489 Mar 7 2006 bin2txt.c

Aquí podemos ver que el resultado que desplegaría ls, en lugar de irse a pantalla, se lo "pasamos" a grep. Y a grep le pedimos que nos regrese las líneas que contengan la cadena "2006".

echo

Despliega en pantalla lo que le pedimos. Por ejemplo:

$ echo "Hola Mundo"
Hola Mundo

Usando algunos direccionadores de consola, podemos enviar algo a un archivo nuevo:

$ echo "Hola Mundo" > abc.txt
$ cat abc.txt
Hola Mundo

También podemos desplegar variables de ambiente:

$ echo $SHELL
/bin/bash

Aquí, $SHELL es una variable de ambiente que indica cuál "shell" estamos usando.

du

Nos despliega el uso de disco de archivos o carpetas.

$ du *
8 abc.txt
8 prueba

Además, podemos pedirle que nos entregue la suma total al final:

$ du -c *
8 abc.txt
8 prueba
16 total

O que cuente también los subdirectorios (en caso de ser directorios):

$ du -sc temp/
24 temp/
24 total

cp

Saca una copia de un archivo o grupo de archivos. Por ejemplo, sacar una copia de un archivo:

$ cp prueba.c respaldo.c

Esto saca una copia de "prueba.c" y la guarda con el nombre de "respaldo.c".

Otro ejemplo:

$cp *.c respaldo/

Esto saca una copia de todos los archivos que terminan en ".c" y los coloca en una carpeta (preexistente) llamada "respaldo".

Último ejemplo:

$ ls respaldo/
abc.c prueba.c
$ cp -R respaldo/ respaldo1
$ ls
respaldo respaldo1
$ ls respaldo1/
abc.c prueba.c

mv

Mueve y/o cambia el nombre a un archivo:

$ mv xyz.c respaldo/

Eso mueve el archivo "xyz.c" al directorio "respaldo".

Para renombrar:

$ mv xyz.c xyz2.c

Y para mover y renombrar:

$ mv xyz.c respaldo/xyz2.c

mkdir

Crea un directorio.

$ mkdir respaldo2

rmdir

Quita un directorio:

$ rmdir respaldo2

NOTA: El directorio debe estar vacío para que funcione.

rm

Quita un archivo:

$ rm hola.c

Pero también, en su forma recursiva, puede borrar un folder y todos sus archivos contenidos:

$rm -R respaldo3/

which

Nos muestra la ruta de un ejecutable:

$ which bash
/bin/bash

whereis

Nos muestra dónde se encuentran archivos del nombre dado en todo el PATH del sistema.

$ whereis bash
bash: /bin/bash /usr/share/man/man1/bash.1.gz

locate

No está disponible en la mayoría de los sistemas, pero cuando si se encuentra, es una herramienta muy útil para encontrar archivos en todo el sistema.

$ locate test.c
/home/roflo/pruebas/test.csv
/home/roflo/pruebas/test.c

ps

Nos muestra la lista de procesos que estamos corriendo:

$ ps
PID TTY TIME CMD
12615 pts/2 00:00:00 bash
13543 pts/2 00:00:00 ps

También podemos encontrar procesos que estén siendo corridos por alguien más:

$ ps -e
PID TTY TIME CMD
1 ? 00:00:01 init
2 ? 00:00:00 migration/0
3 ? 00:00:01 ksoftirqd/0
4 ? 00:00:00 watchdog/0
5 ? 00:00:00 migration/1
6 ? 00:00:00 ksoftirqd/1
7 ? 00:00:00 watchdog/1
8 ? 00:00:00 events/0
9 ? 00:00:00 events/1
10 ? 00:00:00 khelper
[...]

Pero si nos interesa obtener sólo los propios podemos usar grep:


$ ps -ef | grep rodrigof
rodrigof 13728 13727 0 Jun23 pts/3 00:00:00 -bash
rodrigof 12615 12614 0 13:13 pts/2 00:00:00 -bash
rodrigof 16685 12615 0 15:33 pts/2 00:00:00 ps -ef
rodrigof 16686 12615 0 15:33 pts/2 00:00:00 grep rodrigof

gzip y gunzip

La herramienta gzip sirve para comprimir archivos y gunzip para descomprimir:

$ ls
test.txt
$ du test.txt
20 test.txt
$ gzip test.txt
$ ls
test.txt.gz
$ du test.txt.gz
8 test.txt.gz
$ gunzip test.txt.gz
$ ls
test.txt
$ du test.txt
20 test.txt

tar

Puesto que gzip sólo puede comprimir un archivo y no un conjunto de archivos, tar logra esa contraparte. Para "meter" varios archivos a un tar:

$ tar cf test.tar test.txt test2.txt test3.txt
$ ls
test2.txt test3.txt test.tar test.txt

Aquí logramos meter a "test.tar" los archivos "test.txt" "test2.txt" y "test3.txt". Si queremos ver los contenidos de test.tar, podemos hacer:

$ tar tf test.tar
test.txt
test2.txt
test3.txt

Para "desempacar" test.tar, podemos hacer:

$ ls
test.tar
$ tar xf test.tar
$ ls
test2.txt test3.txt test.tar test.txt

Finalmente, podemos hacer que tar utilice gzip al empacar y desempacar:

$ ls
test2.txt test3.txt test.txt
$ tar cfz test.tar.gz *.txt
$ ls
test2.txt test3.txt test.tar.gz test.txt
$ rm *.txt
rm: remove regular file `test2.txt'? y
rm: remove regular file `test3.txt'? y
rm: remove regular file `test.txt'? y
$ ls
test.tar.gz
$ tar xfz test.tar.gz
$ ls
test2.txt test3.txt test.tar.gz test.txt
$ ls
test2.txt test3.txt test.tar.gz test.txt
$ tar cf test.tar *.txt
$ ls
test2.txt test3.txt test.tar test.tar.gz test.txt
$ du test.tar*
60 test.tar
8 test.tar.gz

env

Despliega todas las variables de ambiente definidas.

Se puede usar grep para desplegar sólo algunas que querramos:

$ env | grep GREP
GREP_COLOR=1;37
GREP_OPTIONS=--color=auto

Estas variables de ambiente, le piden a grep que resalte la cadena que buscó dentro de los resultados.

setenv y export

Dependiendo del SHELL que usemos, a las variables de ambiente se les puede escribir valores. Para saber qué SHELL usamos, podemos hacer:

% echo $SHELL
/bin/tcsh

En este ejemplo, el SHELL que se está usando es TCSH. Otro ejemplo:

$ echo $SHELL
/bin/bash

Esto sucede cuando estamos usando BASH.

El shell que estemos usando determina si debemos usar export o setenv. Para TCSH (o CSH) usamos setenv de la siguiente manera:

% setenv DISPLAY breeze:1
% echo $DISPLAY
breeze:1

Para BASH, usamos export.

$ export DISPLAY=breeze:1
$ echo $DISPLAY
breeze:1

ln

lpq

lprm

mount

umount

(ojo, NO es "unmount")