001. Sobre la línea de comandos.

Existen muchas formas de mandarle ordenes a los ordenadores y nosotros vamos a utilizar una que
existe casi desde los comienzos de la computación, superada en antigüedad solo por las tarjetas
perforadas y mecanismos similares.

Las ordenes las entiende el ordenador gracias a una interfaz que permite traducir la
comunicación.

Esta interfaz es posible gracias a dispositivos de 3 tipos:

• De entrada.
• De salida.
• De entrada y salida.

Cuando una persona manda ordenes a un ordenador utilizando la voz, esta le llega al ordenador
gracias a un dispositivo de entrada (un micrófono). El ordenador interpreta la voz y puede responder
por otro dispositivo de salida como podría ser los altavoces o el monitor (incluso ambos).

Cuando una persona utiliza su dedo sobre una pantalla táctil esta utilizando un dispositivo que esta
sirviendo para introducir datos y al mismo tiempo mostrarlos. Ese tipo de pantallas son dispositivos
de entrada y salida y realizan el trabajo de interfaz entre el humano y la maquina.

Nosotros vamos a usar un teclado para dar ordenes. El ordenador se limitará a cumplirlas y para
que nos enteremos de que las esta cumpliendo correctamente nos avisará imprimiendo en pantalla
un texto en un lenguaje que podamos entender.
Para que esto sea posible aparte del dispositivo de entrada (teclado) y del dispositivo de salida
(monitor) vamos a necesitar una interfaz. Esto es a lo que se refieren cuando nos hablan de la
interfaz de línea de comandos.

Esta interfaz antes era física. Eran dispositivos llamados terminales (conocidos también como
consolas) que se comunicaban con un ordenador central mediante una conexión RS-232 (serie).

Varios terminales se conectaban al mismo ordenador central pero con la proliferación de los
miniordenadores, y la posibilidad de estos de comunicarse en red, era posible desde un terminal
controlar otros ordenadores. Era posible gracias al nacimiento de los emuladores de terminal.

Estos emuladores por software permitían y permiten simular ser un terminal de otro ordenador y
poder operar con ordenadores remotamente. Lo que usamos en nuestros sistemas GNU/Linux
actualmente son emuladores de estos terminales ya que solemos ejecutarlos en un escritorio
sobre una interfaz Gráfica.

Estos emuladores de terminal por software es lo que vamos a llamar terminales en este documento
pese a que sabemos y hemos de recordar que no son lo mismo.

Nos referiremos por tanto a terminal como "el sitio donde se puede usar la interfaz de línea de
comandos" sin importarnos si se trata de un emulador, si estamos operando en un equipo remoto o
si estamos en nuestro ordenador tecleando sin una interfaz gráfica.

Otro dato importante a tener en cuenta es que existen muchos interpretes de comandos pero el que
nosotros vamos a utilizar es bash (Bourne again shell) ya que es el intérprete de comandos por
defecto en la mayoría de las distribuciones de GNU con Linux.
 002. Motivos por los que usar la línea de comandos.

2.0 Viviendo juntos en armonía.

2.1 Formas complementarias de mandar ordenes.
2.2 Motivos para manejarse en la línea de comandos.

2.0 Viviendo juntos en armonía

Cuando una nueva tecnología surge la tendencia de la sociedad suele ser la de considerar como
obsoleta la tecnología usada anteriormente.
La televisión no hizo que la radio desapareciese. La gente sigue actualmente escuchando radio ya
que esta tiene una serie de ventajas frente a la televisión.
Por un lado el coste de recursos por parte de los que escuchan es mínimo. Se trata de un circuito que
puedes realizarte en casa de forma muy sencilla mientras que para ver la televisión requieres de un
aparato mucho más costoso.
La radio frente a la televisión permite al oyente mantener la vista centrada en otras tareas mientras
que la televisión acapara nuestra vista y nuestro oído.
Evidentemente esto es solamente un ejemplo. Existen muchos más como por ejemplo el teléfono
fijo y el teléfono móvil.
La existencia de un teléfono móvil no hace que necesariamente lo incorporen en todas las
empresas. Algunas empresas consideran que es mejor montar una centralita interna y utilizar por
cada puesto de trabajo en las oficinas un teléfono fijo en vez de uno sin cables.
Uno de los motivos es que la gente no se lleva los teléfonos a casa por descuido o se los deja en los
baños. Esto obliga a los trabajadores/as a permanecer en su puesto de trabajo el mayor tiempo
posible y finalmente esto supone un ahorro energético por parte de la empresa y de coste por cada
terminal.
Con estos ejemplos lo que se viene a decir es que cuando surgen nuevas tecnologías estas no
necesariamente dejan obsoletas a otras y muchas veces ambas podrán vivir juntas en armonía.
El uso de la línea de comandos no es algo del pasado. El uso de la línea de comandos es futuro.

2.1 Formas complementarias de mandar ordenes

Existen muchos motivos por los que determinada gente odia la línea de comandos.
Con una tablet la forma con la que mandamos ordenes suele ser usando el dedo o varios dedos. No
es algo tan distinto de lo que emplean algunas personas cuando se les da un ordenador y un teclado,
es decir, teclean con un dedo ya que no han aprendido mecanografiá (dactilografía es un termino
más correcto).
Uno de los motivos por los que la linea de comandos no es para todo el mundo es por que requiere
de unos conocimientos previos de los que algunas personas carecen. Esto hace que ya no sea algo
apto para todo el mundo pero no por ello algo desfasado.
En el caso de un usuario/a que utiliza una tablet posiblemente la mayoría de las veces utilice el dedo
sobre la pantalla y otras veces utilizará la voz para buscar por ejemplo algo en un buscador web.
Esto supone que esta utilizando formas diferentes de mandar ordenes simultaneas cuando
más le interesa.
Una cosa no quita la otra como suele decirse.
La línea de comandos por tanto es una forma de introducir ordenes al ordenador pero esta puede
combinarse con otras sin que esto resulte una aberración.
Mientras que desde la línea de comandos eliminar determinados directorios o copiar determinados
ficheros es muchas veces más rápido de realizar que usando una interface gráfica esto no quita que
el uso de por ejemplo un gestor de archivos gráfico pueda ser de muchísima utilidad para muchas
otras cosas.
El ejemplo de las fotos.
Tienes como 50 fotos de una semana en la playa con tu pareja y quieres justo una en la que sale una
gaviota posada sobre una papelera. Desde la línea de comandos no sabes cual es esa foto mientras
que si visualizas el directorio usando un gestor de archivos gráfico (como por ejemplo nautilus)
podrás ver una miniatura de la foto sin necesidad de ir abriendo una a una.
Ahora resulta que te vas de viaje a Canarias y sacas 5000 maravillosas fotos de todo tipo. Eres una
persona despistada y siempre olvidas destapar la tapa del objetivo de la cámara de modo que sacas
muchísimas fotos en negro que no has borrado.
Cuando mueves las fotos a tu ordenador puedes acceder de forma visual e ir viendo las pre-
visualizaciones pero con calma ya que en el directorio tienes 5000 fotos y generar la pre-
visualización de tantas fotos a tu ordenador le cuesta.
Aparte de consumir muchos recursos es poco cómodo ir buscando a mano todas las fotos que salen
en negro pero como eres una persona que se maneja bien también en la linea de comandos borrar
todas las fotos en negro no te costará mucho.
Las fotos en negro ocupan siempre mucho menos que el resto. Podrías por tanto desde linea de
comandos simplemente filtrar las fotos que tengan un tamaño menor que X y que estas se eliminen.
Con un solo comando podrías realizar esta tarea y podrías almacenar ese comando para que
invocarlo fuese más sencillo la siguiente vez.
Desde la interface gráfica podrías incluso configurar una acción para que seleccionando un
directorio o haciendo clic derecho automáticamente se borrasen las fotos en negro.
Esto es gracias a combinar ambos mundos.
2.2 Motivos para manejarse en la línea de comandos.

Existen muchos motivos para aprender a manejarnos en la línea de comandos. Estos solamente son
algunos de ellos:
Menor consumo de recursos. Esto puede parecer una tontería pero no es así. Por desgracia los
recursos en nuestros sistemas son finitos. Un buen empleo de los recursos de nuestro sistema
muchas veces pasa por realizar determinadas tareas utilizando la línea de comandos en vez de
realizar las cosas mediante el uso de herramientas gráficas.
Control remoto de una maquina. El consumo de recursos para el control remoto de una maquina
de forma gráfica es mayor que el que supone controlarla de forma remota utilizando un emulador de
terminal. En el caso de servidores en la mayoría de los casos estos no disponen de una interface
gráfica de modo que solamente pueden ser controlados de forma remota mediante la línea de
comandos.
Utilización de alias. Esto es una característica de algunos interpretes de comandos (como bash) que
nos permiten en un comando corto y fácil de escribir ejecutar uno largo y complicado de recordar y
escribir. El uso de alias nos permite personalizar a nuestro gusto algunos comandos.
Potencia para realizar muchas tareas. Podemos automatizar tareas y podemos realizar muchas de
golpe. Es por esto que la línea de comandos tiene la potencia que tiene. La combinación de las
entradas y salidas de muchos programas hace posible renombrar, redimensionar, comprimir,
eliminar, … archivos de forma rápida.
Renombrar 2 millones de archivos es más sencillo desde la línea de comandos que no desde la
Interface Gráfica.
Cambios rápidos de usuario. Como norma general en un entorno gráfico usamos solamente un
usuario para realizar las cosas y todo lo que vemos esta personalizado para ese usuario. El usuario
dispone de un escritorio y para cambiar y realizar tareas como si fuese otro usuario necesita cerrar
sesión y realizar login. En realidad no necesita cerrar la sesión, puede mantener ambas al mismo
tiempo abiertas y regresar a la anterior pero eso suponen muchísimos recursos de sistema y tiempo.
Desde la línea de comandos vamos a poder rápidamente realizar tareas como si fuésemos un usuario
diferente en el sistema ya sea en nuestra maquina o en otras maquinas remotas.
Automatizar. No necesitamos hacer las cosas mil veces. Aprender a automatizar tareas nos
permitirá poder centrarnos en otras más importantes.

En general estos son solamente una serie de motivos por los que la gente sigue usando la interface
de línea de comandos. No hace falta ser un administrador de sistemas para manejarse en una
terminal y aprender será una experiencia para poder entender realmente como funciona un sistema
GNU/Linux.
Aprendiendo primero a manejarnos desde una línea de comandos entenderemos mejor la interface
gráfica. Estaremos empezando la casa por los cimientos y no por el tejado y tendremos la capacidad
de comprender en nuestro día a día cuando es mejor utilizar una u otra cosa.
 003. Manos a la obra

3.1 Conectar a un ordenador remoto.

3.2 En el restaurante.
3.3 Entrando por primera vez.
3.4 Quiénes somos, de donde venimos y a donde vamos

3.1 Servidor y cliente.

Este taller vamos a seguirlo cada uno/a desde nuestra computadora. Posiblemente en nuestra casa.
No importa si no disponemos de un ordenador con GNU/Linux para seguir este taller ya que
vamos a conectarnos a un ordenador que si que tiene instalado GNU/Linux y lo vamos a hacer
de forma remota.
Para que sea posible esta conexión es necesario que tanto la maquina a la que vamos a conectarnos
como las maquinas desde las que iniciamos esta conexión (nuestros equipos) tengan un cliente y un
servidor SSH.
El ordenador que en la foto esta en Alemania es al que vamos a conectarnos. Ese es un ordenador
que ofrece un servicio y dispone de un sistema operativo GNU/Linux.
Ese servicio consiste en ofrecer acceso remoto a diferentes usuarios. Al ser un ordenador que ofrece
servicios lo llamamos servidor.
En nuestras maquinas vamos a necesitar lo contrario. Nuestras maquinas no van a ofrecer un
servicio y si todo lo contrario, van a disfrutar de un servicio. Nuestras maquinas actuarán como
clientes.

3.2 En el restaurante.

Para entender el concepto supongamos que el ordenador de Alemania es un restaurante y que los
ordenadores clientes actúan como eso mismo.
El cliente de Argentina llega a Alemania al restaurante y antes de entrar en la puerta se encuentra a
un guarda de seguridad. Este le pregunta si ha reservado mesa y el cliente argentino le dice que que
evidentemente. El guarda de la puerta le pide que indique su nombre y el cliente se lo dice. El
guardia posteriormente se queda mirando la cara del argentino a ver si este hace o dice algo. El
Argentino le dice “Ché boludo, ¿me dejas acceder a la concha de tu madre?”.
El puerta sabe que para acceder a este prestigioso restaurante la clave para el cliente argentino era
exactamente esa. Le deja pasar.
Ocurre lo mismo con todos los clientes de diferentes sitios. Cada uno va a tener que pasar por la
puerta y validarse.
Una vez dentro del restaurante el cliente Griego pide una Musca con patatas, el cliente brasileño
solicita al camarero una caipirinha bien cargada para acompañar la moqueca.
Los camareros y cocineros se ponen manos a la obra y se encargan de que todo lo que pidan los
clientes este listo lo antes posible tal y como lo piden.
El cliente chileno es muy especial y quiere que la sopa se la lleven con exactamente 20 fideos
integrales de comercio justo. El servicio del restaurante se encarga de que así sea.
El cliente francés trata de entrar hasta la cocina pero cuando va a cruzar la puerta aparece un guarda
de seguridad y le dice que se tranquilice. El cliente francés no tiene acceso a la cocina ya que se
trata de un cliente y no de un empleado del restaurante.
En las maquinas GNU/Linux sucede algo así. Los clientes serán usuarios del sistema con una serie
de permisos. En su mesa van a poder derramar si quieren la bebida pero no van a poder ir a la
cocina y no van a poder derramar la de otros en otras mesas.
Por tanto nos ha de quedar claro que el restaurante seria en este caso el sirviente, el servidor y
nosotros simples clientes limitados a poder realizar solamente lo que se nos permite en nuestra
mesa.
3.3 Entrando por primera vez.

Independientemente del sistema operativo que tengamos para acceder a este taller y poder practicar
vamos a usar un servidor GNU/Linux al que nos conectaremos remotamente.
Para esto necesitamos tener instalado en nuestro sistema un cliente SSH.
Existen muchos pero si por ejemplo andas en Windows puedes utilizar putty.
Esta disponible desde aquí: http://www.putty.org/
Los datos para acceder son un login, una contraseña y un puerto.
El puerto es como la puerta del restaurante, el login es nuestro nombre y la contraseña lo que indica
que realmente somos alguien que puede acceder.
Estos datos son individuales y cada persona que ha solicitado asistencia a este taller dispondrá en su
correo de la información y credenciales necesarios.
En cualquier caso se ayudará a quienes tengan problemas.
Una vez hemos entrado correctamente vamos a poder interaccionar directamente con la maquina
remota. Esta maquina esta realmente en Alemania.
Como es la primera vez que entramos vamos a utilizar una serie de comandos que nos ayudarán a
saber quiénes somos, de donde venimos y a donde vamos.

3.4 Quiénes somos, de donde venimos y a donde vamos

El primer comando que vamos a utilizar es:

$ pwd
Pwd ha de ser escrito todo en minúsculas ya que de lo contrario va a fallar. Esto en informática se
denomina “sensible a las mayúsculas y minúsculas” y del inglés nos viene “case sensitive” que
siempre queda más cool dicho en público.
Recordemos pues que aquí no vale escribir PWD y que funcione. En este restaurante Alemán
figurado si les pides una fanta y lo llamas con otro nombre no van a traerte una fanta. Lo mismo si
pides que la fanta sea light, zero o de limón o naranja. Hemos de dar las ordenes bien dadas y
exactas de lo contrario el servicio no nos va a atender ni entender.
Pwd nos va a decir donde estamos. En nuestro caso inicialmente estaremos en
/home/nombredetuusuario y cada uno de nosotros/as estaremos en un directorio por tanto diferente
pero todos dentro de home.
Inicialmente al acceder estaremos por defecto en este directorio. Hemos por tanto de saber que
home es un directorio donde dentro están otros directorios llamados como los usuarios del sistema.
Es como si home fuese el restaurante y dentro del restaurante cada cual estamos en un reservado
independiente.
Como somos gente inquieta lo mismo queremos ir al baño o visitar a otra gente en otras mesas para
ver que están tomando. Vamos a poder movernos por el restaurante pero hemos de recordar siempre
que si no sabemos muy bien donde estamos usando pwd vamos a poder saberlo.
El comando por tanto para saber donde estamos es pwd y será el que le digamos a los
camareros cuando estemos perdidos/as.
Para caminar e ir de un lado a otro en el restaurante vamos a necesitar otro comando. En este caso
ese comando es el siguiente:
$ cd
Change directory es la palabra en inglés. Nos sirve para cambiar de directorio y por tanto para
movernos.
Los directorios son como carpetas donde dentro podemos meter otras carpetas y dentro de esas
carpetas otras carpetas o ficheros.
En el caso de home hemos dicho que es el salón del restaurante y en ese salón tenemos cada cliente
nuestro reservado. En este caso todos los clientes estarán en home que es el salón y dentro de cada
mesa reservada estarán los platos, tenedores o lo que le de la gana al cliente. El cliente podría meter
otra mesa más en su reservado si quiere y dentro de esa mesa otra mesa. Es una locura pero es así.
Podemos por tanto deducir que en nuestro reservado podemos hacer lo que nos de la gana. Podemos
crear ficheros, borrarlos, moverlos, renombrarlos, … cuando queramos.
En los reservados de otros clientes no vamos a poder por defecto borrar nada pero si que podemos
ver que tienen en sus mesas y copiarnos de sus platos si nos gustan y nos dejan. De ese modo
podemos pedir una copia a los camareros.
Ahora mismo estamos en nuestro directorio dentro de /home/ y para movernos hacia atrás usaremos
el comando:
$ cd ..
De esta forma salimos de ese directorio y entramos en el inmediatamente superior.
Ahora estamos en disposición de ver todas las mesas de todos los usuarios. Esto vamos a poder
hacerlo usando el comando:
$ ls
Es una ele y una ese. Viene de list y nos permite ver un listado rápidamente de lo que tenemos en el
directorio actual.
Vamos a ver muchos directorios de mucha gente. Podemos entrar en ellos así.
$ cd nombreusuario
Como vemos con cd podemos cambiar a directorios de forma rápida. Podemos regresar a nuestro
home si indicamos la ruta completa.
$ cd /home/nuestronombredeusuario
Ya sabemos por tanto movernos por los diferentes directorios aunque no sepamos aún la estructura
típica de un sistema GNU/Linux. No importa ahora mismo. Sigamos pues recordando que sabemos
donde estamos en todo momento con pwd, que podemos ver el contenido de donde estamos con ls y
que si queremos movernos podemos usar cd
¿Quién soy yo?

Ya estamos por tanto preparados para ir reconociendo un poco el ambiente pero sabemos muy poco
de nostros y de los que nos rodean. Vamos a usar whoami.

$ whoami

Este comando muestra el nombre de usuario/a asociado con el ID efectivo del usuario actual. Nos
dice el nombre del usuario con el que estamos tecleando.

Es muy importante saber quienes somos cuando manejamos un terminal. Es importante ya que
depende que usuario utilicemos en el sistema vamos a poder realizar unas cosas y no otras. Esto lo
explicaremos más adelante en profundidad.

Por ahora es bueno saber que en los sistemas GNU/linux vamos a tener como norma general 2 tipos
de usuarios: root y el resto.

El usuario root es un usuario para el que esta permitido todo en el sistema mientras que el resto
como norma general no van a poder ejecutar algunos programas ni escribir en determinados
directorios.

El símbolo del dolar $ indicará que somos un usuario mientras que si fuésemos el usuario root el
símbolo se cambiaría por # la almohadilla.

Ahora que sabemos quien somos tenemos que ver quienes somos.

$ who

Con esta orden vamos a ver cuantos usuarios están actualmente conectados al sistema y ahora
analizaremos la salida. Supongamos esta salida impresa en pantalla:

fanta tty1 2014-12-21 03:51

fanta pts/0 2014-12-18 10:18 (:0.0)
pedro pts/1 2014-12-20 21:17 (46.27.9.3)
fanta pts/2 2014-12-21 03:41 (:0.0)

Muestra información sobre los usuarios/as (a partir de ahora usaremos usuarios tanto para mujeres
como hombres) que están actualmente conectados.

La primera columna indica el nombre de los usuarios, la segunda columna indica el nombre de
archivo para la entrada estándar (explicaremos esto ahora después), la tercera columna ofrece
información sobre la fecha en la que se ha iniciado el acceso así como la cuarta indica la hora a la
que se ha entrado. La quinta columna muestra información sobre desde donde estamos conectados
(explicaremos en detalle esto también).

La fecha y hora de acceso es algo que no tiene mucho que explicar mientras que si que cabe
destacar que existen 2 usuarios diferentes en el sistema (fanta y pedro) y que fanta tiene abiertos
3 accesos.

La segunda columna muestra tty1 y pts/x (donde x es un número). Esto es lo que en inglés se llama
terminal line y es el archivo para la entrada estándar (el teclado) de esa linea de terminal.

Por convención, todo programa en plataformas Unix o GNU/Linux posee tres canales básicos por
donde fluye la información, estos canales son: salida estándar, entrada estándar y error
Estándar.

Nos interesa saber que la entrada estándar es el teclado y la salida estándar es el monitor.

Si abrimos varios terminales desde nuestro escritorio y usamos la orden who veremos que pts/x va
aumentando el número. Eso indica que se le va asignando un fichero donde va mandando lo que
escribe por el teclado.

Para saber en que fichero estamos escribiendo nosotros (y que el sistema usa para interpretar lo que
escribimos) en el actual terminal usaremos el comando tty.

$ tty
Eso nos indicará algo similar a esto:

/dev/pts/2

Hemos de saber que cuando hacemos login en el sistema de forma gráfica estamos accediendo con
un usuario al que se le asignará /dev/pts/0 . Si en vez de acceder de forma gráfica accedemos usando
la combinación control + alt + 1 nuestro usuario mostrará /dev/tty1 como norma general.

Eso ocurre si lo hacemos en una maquina GNU/Linux instalada en nuestro sistema. Recordemos
que estamos conectados remotamente a una maquina en Alemania.

Respecto a la quinta columna hemos de comentar que si estamos en un equipo remoto veremos la
ip desde la que estamos conectando (nuestra IP pública) y en el caso del supuesto pedro esta
conectado a ese equipo de forma remota. En caso de estar conectados desde la interface gráfica
usando un terminal veremos que se asigna el X display mientras que si lo hacemos desde la consola
(sin usar las X, la interface gráfica) no se mostrará nada.

Otra orden para obtener más información sobre los usuarios del sistema es w.

$w

Nos mostrará más información sobre los usuarios del sistema. Es interesante y cabe destacar que
muestra el programa que están ejecutando y por tanto nuestro usuario actual saldrá usando w.
 004. Archivos y directorios

4.1 Creando directorios

4.2 Visualizando
4.3 Diferentes nombres para un mismo archivo

4.1 Creando directorios.

Para crear un directorio vamos a utilizar la orden mkdir.

$ mkdir
Si no indicamos el nombre del directorio que queremos crear no funcionará.
Vamos a crear un directorio llamado personajes en nuestro home. En mi caso en /home/fanta/
$ mkdir personajes
Una vez creado el directorio personajes vamos a entrar usando cd.
$ cd personajes
Hemos entrado al directorio personajes y ahora vamos a crear 2 directorios. Uno llamado Stallman
y otro llamado Linus (sin la x).
$ mkdir Stallman
$ mkdir Linus
Hemos creado esos 2 directorios y ahora vamos a crear otros 2 llamados Jackson y Anderson pero
vamos a hacerlo del tirón:

$ mkdir Jackson Anderson

Si separamos con un espacio los nombres de los directorios podemos indicar la creación de varios
“del tirón”.

Como ya conocemos la orden pwd podemos saber en todo momento donde estamos. Ahora estamos
dentro del directorio personajes y es el momento de crear archivos y aprender a visualizar
directorios y su contenido.

4.2 Creando directorios.

Estamos dentro del directorio personajes. Vamos a acceder al directorio Stallman así:
$ cd Stallman
Y una vez dentro vamos a crear varios archivos sin nada en su interior. Es el momento de usar
touch.
$ touch archivo1.txt
Eso generará un fichero llamado archivo1.txt sin nada en su interior.
Touch no se usa solamente para crear archivos pero eso lo veremos luego. Ahora vamos a crear 5
archivos llamados: archivo2.txt archivo3.txt archivo4.txt archivo5.txt
$ touch archivo2.txt archivo3.txt archivo4.txt archivo5.txt
Como puede verse se puede hacer de uno en uno o separando los nombres de archivo con un
espacio para hacerlo de golpe.
Ahora es cuando vamos a ver como visualizar los archivos que existen dentro de un directorio. No
solamente archivos, veremos que podemos visualizar también cualquier directorio.
$ ls
La salida del comando ls mostrará todos los 5 archivos. Mostrará solamente los nombres.
Como sabemos ya crear directorios vamos a crear también un directorio llamado imagenes.
$ mkdir imagenes
Eso generará un directorio llamado imagenes. Si utilizamos ahora el comando ls vamos a ver que
existen los 5 ficheros y también el directorio imagenes.
Dependiendo del terminal que estemos usando vamos incluso a ver en diferente color lo que es un
archivo y un directorio.

De todos modos es posible que no sea así y aparte no estamos viendo nada relativo a cada uno de
los archivos y directorios, es decir, solo conocemos usando ls de esta forma el nombre.
Para ver más información podemos usar argumentos.
$ ls -l
Tras escribir ls metemos un espacio y luego -l (un guión y una ele minúscula).
Ahora vamos a ver que sale mucha más información. No es el momento de entender ahora mismo
todo lo que sale pero si al menos algunas columnas.
De la primera columna hemos de comentar y saber que eso raro que se ve son los permisos de ese
archivo. No hace falta que lo entendamos pero si hemos de conocer que si comienza con una d se
trata de un directorio.
Tenemos 5 archivos y un directorio por tanto y aparte de eso sabemos la fecha en la que han sido
creados esos archivos así como el tamaño que tienen. Los archivos creados con touch ocupan 0
mientras que los directorios ocuparán 4096 por defecto.
La realidad es que todo ocupa incluso los nombres. Esto depende del sistema de ficheros que
estemos usando. El comando ls y otra serie de comandos que veremos ahora después no tienen en
cuenta el tamaño de los nombres de archivo pero esto en realidad esta ocupando espacio.
En GNU/linux puedes instalar el sistema en muchísimos sistemas de ficheros pero lo normal
será usar a nivel de usuario sistemas de ficheros ext2 ext3 ext4 mientras que por ejemplo en
sistemas operativos como windows el sistema de ficheros empleado será NTFS.
Lo que importa es conocer que antes de que windows usase NTFS se usaba FAT8, FAT16 y FAT32.
En sistemas operativos como MSdos y los primeros Windows los nombres de archivos solamente
podían tener 8 caracteres + 3. Eso es lo que se llamaba el 8.3 y significaba que el archivo solamente
podía tener 8 caracteres para el nombre y 3 para la extensión.
En GNU/Linux son 255 bytes lo que puede ocupar de máximo el nombre y pese a que
comandos como ls y otros no muestran lo que realmente esta ocupando el nombre hemos de saber
que todo ocupa espacio.
Esto nos sirve para conocer el limite del nombre de archivo que podemos darle.
ext2 255 bytes
ext3 255 bytes
ext3cow 255 bytes
ext4 255 bytes
FAT32 8.3 (255 UCS-2 code units with VFAT LFNs)[22]
NTFS 255 characters

Para probarlo vamos a tratar de crear un archivo con touch con un nombre muy largo. Ejemplo:
$ touch
01234567890123456789012345678901234567890123456789012345678901234567890123456789
01234567890123456789012345678901234567890123456789012345678901234567890123456789
01234567890123456789012345678901234567890123456789012345678901234567890123456789
012345678901234567890123456789012345678901234567890123456789.txt
Ese nombre de fichero es demasiado largo y por tanto no se va a poder crear. Nos avisará de que el
nombre del archivo es demasiado largo (File name too long).
Hemos por tanto de tener en cuenta que el limite son 255 caracteres.
Realizamos de nuevo un ls con la opción esta vez de -la
$ ls -la
Esta vez vemos que salen más directorios. Los reconocemos ya que empiezan con la letra d en la
columna 1.
Esos nuevos directorios siempre están allí y se llaman . y ..
Nos vale saber que cuando usamos cd .. cambiamos al directorio inmediatamente superior, es decir,
si queremos salir del directorio Stallman en el que nos encontramos podemos usar cd .. pero no
vamos a hacerlo. Conocer esto nos sirve para saber que . indica el directorio actual y que .. indicará
el directorio inmediatamente superior.
Lo vamos a ver y entender ahora después en la siguiente sección (4.3) con claridad.
Ahora que sabemos esto vamos a probar diferentes argumentos de ls que nos sean de utilidad.
$ ls -S
Muestra la salida ordenando por tamaño. Veremos los archivos o directorios de mayor tamaño antes.
$ ls -Sr
Eso ordenará por tamaño pero nos lo mostrará a la inversa. Primero los archivos/directorios de
menor tamaño.
Existen muchas más opciones documentadas si usamos el argumento –help
$ ls --help

4.3 Diferentes nombres para un mismo archivo

En GNU/Linux vamos a poder darle más de un nombre a un mismo archivo. En la vida real es
posible que una persona tenga diferentes nombres. La gente a Manuel lo puede llamar Lolo, Manu,
Manolo, … y se refieren a la misma persona.
Cada archivo en el sistema está representado por un inodo. Ese inodo es un númerito.
Podemos ver el inodo de un archivo o directorio usando ls. Así:
$ ls -li
Esos numeritos que salen en la primera columna son bloques que almacenan información sobre los
archivos/directorios del sistema. De esa forma a cada inodo se le asigna un nombre.
Ha de quedar claro por tanto que la información relacionada con el archivo se almacena en un
bloque al que se puede acceder gracias a ese numerito.
Este bloque al que llamamos inodo contiene esta información:
• El número de inodo que identifica al archivo dentro del sistema de archivos
• La longitud del archivo en bytes.
• El identificador de usuario del creador o un propietario del archivo con derechos
diferenciados
• El identificador de grupo de un grupo de usuarios con derechos diferenciados
• El modo de acceso: capacidad de leer, escribir, y ejecutar el archivo por parte del propietario,
del grupo y de otros usuarios.
• Las marcas de tiempo con las fechas de última modificación (mtime), acceso (atime) y de
alteración del propio inodo (ctime).
• El número de enlaces, esto es, el número de nombres de este inodo.
Un inodo no es más que un bloque que almacena información de los archivos, de esta manera a
cada inodo podemos asociarle un nombre. A simple vista pareciera que a un mismo archivo no
podemos asociarle varios nombres, pero gracias a los enlaces esto es posible.
Nos ha de quedar por tanto claro antes de seguir lo siguiente:
- Un archivo puede tener muchos nombres y seguir siendo el mismo archivo.
- La información relativa al archivo estará en el inode.
- Los nombres del archivo y las propiedades de ese archivo son algo diferente.
- Los nombres de archivos tienen un limite de 255 bytes.

I-node no lo ha inventado Apple. Un nombre como cualquier otro.

Steve Jobs no inventó nada en su vida y desde luego no le puso nombre a esto.
El Dr. Dennis Ritchie explicaba lo siguiente referente al nombre de inode:

Realmente, tampoco lo sé. Era simplemente el nombre que comenzamos a utilizar.

"Índice" es lo mejor que se me ocurre, debido a la estructura algo inusual de un sistema
de ficheros que almacenaba la información del acceso a los archivos como una lista
plana en disco, dejando al margen toda la información jerárquica de los directorios. Así
el número "i'" es un índice sobre la lista, el nodo "i" es el elemento seleccionado de la
lista. (En la primera edición del manual se empleó la notación "i-nodo"; el guion fue
desapareciendo poco a poco).
Para entender como asignarle más de un nombre a un mismo archivo vamos a usar el comando ln
$ ln
Escrito sin argumentos no hace nada.
El programa ln es el que invocaremos escribiendo ln y nos servirá para crear enlaces.
No vamos a profundizar sobre los tipos de enlaces existentes pero cualquiera puede buscar
información sobre enlaces en GNU/Linux y ampliar.
Los enlaces son como accesos directos en windows pese a no ser exactamente lo mismo.
Antes hemos comentado que el bloque inode de un archivo contiene información sobre cuantos
enlaces tiene ese archivo. Eso son el número de enlaces por lo que si escribimos lo siguiente
veremos que no tienen nada más que 1.
$ ls -li
Los archivos llamado archivo1.txt, archivo2.txt, … solamente tienen un enlace. Esto lo veremos en
la tercera columna si hemos escrito esa orden.
Los directorios los creábamos con mkdir y tendríamos que tener por tanto creado uno llamado
imagenes.
Veremos que ese no tiene un 1, tiene un 2. Para entender esto primero vamos a crear un enlace al
archivo llamado archivo1.txt de esta forma:
$ ln archivo1.txt mierda.txt
Ahora vamos a hacer ls -li para ver que el número ahora es 2 y vamos a crear unos cuantos enlaces
más con diferentes nombres para comprobar que el número va creciendo.
El motivo por el que los directorios tienen un 2 y un 1 es por que están enlazados por su propio
nombre y por el directorio “especial” del punto: .
Cuando hacemos un ls -la veremos que aparecen los directorios . y .. y habíamos dicho que el
directorio . nos enlaza al directorio actual y que el directorio .. nos enlaza al directorio
inmediatamente superior (nos saca del actual).
El contenido de archivo1.txt y mierda.txt será el mismo y vamos a poder acceder al mismo archivo
usando los diferentes nombres.
 005. Modificando archivos

5.1 Nano - Un editor de archivos simple

5.2 Copiar y mover archivos y directorios
5.3 Eliminar archivos y directorios

5.1 Nano - Un editor de archivos simple

Desde la línea de comandos vamos a poder editar archivos. Antes de empezar con esto vamos a
recordar algunos comandos de los que hemos ido viendo.
$ mkdir
Nos servia para crear directorios.
$ ls
Para visualizar archivos y directorios
$ pwd
Para saber donde estamos.
$ cd
Para cambiar a otro directorio.
$ who
Quienes están conectados en el sistema.
$ touch
Para entre otras cosas crear un archivo sin nada en su interior.
$ ln
Para crear enlaces a archivos (como si fuesen accesos directos).
Hasta aquí todo bien. Podemos movernos por los diferentes directorios del sistema y ver los
archivos y directorios que están en cada sitio.
Si deseamos crear un archivo donde por ejemplo guardar una lista de ingredientes de por ejemplo
una hamburguesa lo ideal seria crear un directorio llamado recetas y luego acceder a este.
$ mkdir recetas
$ cd recetas
Esto es por tanto lo que vamos a hacer. Dentro del directorio recetas vamos a introducir varias
recetas de cocina simples y para ello vamos a necesitar un editor de archivos que nos permita
guardar un texto.
Ese editor en nuestro caso va a ser nano . Ese es su nombre y aunque existen muchos otros muy
buenos como por ejemplo emacs o vim nosotros usaremos nano por lo sencillo que es usarlo.
Necesitamos por tanto saber abrirlo. Esto es así de sencillo:
$ nano
Escribiendo nano ya se abre el editor de texto.

Para salir del editor usaremos la combinación de teclas Control + x

Nosotras/os vamos a indicar al ejecutar nano el nombre del fichero que queremos editar o crear. En
nuestro caso vamos a indicar la receta de un huevo frito y por tanto vamos a crear un archivo
llamado huevofrito.txt
$ nano huevofrito.txt
Si realizamos eso el archivo en realidad no se generará hasta que no guardemos cambios o
escribamos algo. Si simplemente abrimos nano indicando ese nombre de fichero y luego salimos
usando Control + x no se guardará ni se generará ningún fichero.
Una vez estamos dentro de huevofrito.txt ya podemos escribir. Escribiremos pues los ingredientes
de la receta.
- Huevo.
- Aceite de oliva virgen extra.
- Sal.

Es el momento de guardar el archivo. Para guardar usaremos Control + o

Si queremos guardar y salir usaremos Control + o y luego Control + x
No necesitamos saber mucho más para editar archivos. Eso es lo básico de este editor.
Evidentemente este editor permite muchas más cosas pero eso es lo vital para poder crear/editar
archivos.
De todos modos si algunas queréis saber algo más podéis dentro del editor usar estas otras opciones:
- Control + w – Nos permite buscar una palabra (por ejemplo Huevo). Nos posicionará luego allí.
- Control + r y luego Control + t – Nos permite insertar otro archivo en nuestro archivo actual.
- Alt + a - Seleccionar texto usando los cursores.
- Escape + 6 – Copiar una vez hemos seleccionado algo.
- Control + k – Cortar una linea entera. Si hemos seleccionado antes cortaremos la selección.
- Control + u – Pegar en otro lado lo que hemos copiado o cortado.
- Control + t – Corrección ortográfica.
Existen más pero como hemos dicho con saber guardar y cerrar tendremos posiblemente la vida
resuelta para editar archivos sencillos o crearlos.
Crearemos otras 2 recetas y meteremos en su interior solamente los ingredientes tal y como se ha
indicado antes. Esas recetas son las siguientes y tendrán estos nombres de archivo:

nombre del archivo: patatasfritas.txt

- Patatas.
- Aceite de oliva.
- Sal.
Nombre del archivo: pastaconsalsapesto.txt
- Pasta.
- Agua.
- Albahaca
- Piñones
- Aceite
- Queso parmesano.
- Sal.
- Mantequilla.
Vamos a crear esas 2 recetas más usando nano. Una vez las tenemos creadas y contienen los
ingredientes en su interior vamos a crear un cuarto archivo donde vamos a insertar el contenido de
esas 3 recetas. Ese archivo se llamará todas.txt
Para hacer esto usaremos nano.
$ nano todas.txt
Entonces vamos a escribir el nombre de la receta del huevo:
Ingredientes para hacer un huevo frito
Una vez lo hemos escrito pulsamos intro y luego control + r y control + t
Seleccionamos el archivo huevofrito.txt pulsamos intro y tendremos los ingredientes en nuestro
nuevo documento importados.
Hacemos lo mismo para el resto de recetas, es decir, Le metemos Una cabecera que diga
“Ingredientes para hacer pasta con salsa pesto” y “patatas fritas” e importamos el contenido de otros
archivos.
Finalmente guardamos los cambios con Control + o y salimos con control + x
Ya somos unos/as maquinas usando nano :).

5.2 Copiar y mover archivos y directorios

Sabemos movernos entre directorios, sabemos ver que tienen y sabemos crear archivos y escribir en
ellos usando un editor de texto.
Esto sirve para poco pero sirve. Si por ejemplo tuviéramos que modificar una página web en un
servidor ya sabríamos hacerlo accediendo vía ssh al servidor y accediendo al directorio donde se
encuentra el archivo.
Usando nano podríamos acceder al documento y alterarlo.
Mucha gente que se dedica al diseño web lo que hacen es utilizar clientes ftp como filezilla. De esa
forma acceden al directorio remoto del servidor y desde allí se bajan los archivos que quieren editar.
En su ordenador con un programa editor los editan y guardan. Una vez realizado eso lo que hacen
es subirlos de nuevo y sobre-escribirlos.
Todo ese proceso nosotras/os lo realizamos en vivo directamente conectándonos al servidor y
trabajando allí. De esta forma evitamos andar bajando y subiendo archivos constantemente.
Todo esto es muy bonito pero … ¿que pasará si cuando editamos un archivo lo editamos mal y
no tenemos una copia?
Es momento de aprender a copiar archivos.
$ cp
El comando cp nos va a servir para esto. Viene de “copy” y sirve para copiar archivos.
Vamos a copiar el archivo huevofrito.txt para tener una copia llamada huevofrito.txt.bak
$ cp huevofrito.txt huevofrito.txt.bak
Si ahora hacemos un ls vamos a ver que se ha creado una copia del archivo llamada
huevofrito.txt.bak .
No nos asustemos con las dobles extensiones e incluso triples.
En Windows y otros sistemas operativos no es muy normal encontrarse archivos con dobles
extensiones ya que entre otras cosas lo que hace el gestor de archivos en windows es ocultarlas y
solamente mostrar una extensión.
En GNU/Linux es muy normal usar dobles/triples extensiones para los archivos. Un ejemplo podría
ser el siguiente:
huevofrito.txt.zip.rar
Esto lo tendríamos que interpretar desde el final hasta el principio.
Entenderíamos pues que se trata de un archivo comprimido en rar. Necesitaríamos el programa rar
para descomprimirlo. Una vez descomprimido encontraremos un fichero zip en su interior.
Tendremos que descomprimir el fichero zip para finalmente encontrar el archivo txt.
En nuestro caso hemos usado la extensión bak para entender que se trata de un backup (un archivo
copia de seguridad). La extensión nos la inventamos y bien podría tener un nombre así:
huevofrito.txt.copia
Ahora que ya sabemos copiar archivos vamos a ver si somos capaces de copiar directorios.
Para ello vamos a salir del directorio actual al inmediatamente superior.
$ cd ..
Hacemos un ls para ver el nombre de los directorios y archivos
$ ls -l
Veremos que existe el directorio recetas y vamos a copiarlo para tener otro llamado recetas2
$ cp recetas recetas2
Va a fallar. Para que funcione utilizaremos esto otro:
$ cp -R recetas recetas2
Añadiendo el argumento -R (mayúscula) podemos copiar recursivamente. Esto significa que sin
indicar -R podemos copiar un archivo determinado o un directorio sin nada en su interior. En el
momento que tienen contenido en su interior hemos de indicar -R.
En nuestro caso nuestro directorio recetas tiene archivos dentro y por eso hemos de usar -R.
Si realizamos un ls vamos a ver que ya existe otro directorio llamado recetas2.
En el interior de ese directorio tendremos copias de los archivos ya que hemos copiado todo.
No vamos a entrar esta vez dentro usando cd. Vamos a usar esta vez un comando llamado tree que
nos permitirá ver la estructura en árbol y por tanto ver tanto los archivos dentro de recetas como los
archivos dentro de recetas2.
$ tree
Si nos apetece ver con algo más de estilo esa salida usaremos:
$ tree -A
Tendríamos que ver el contenido de ambos directorios del tirón.
En caso de en vez de querer copiar queremos mover un archivo usaremos el comando mv.
$ mv recetas/huevofrito.txt recetas2/otrareceta.txt
Con el comando mv por tanto no quedará una copia. Lo que hacemos es mover un archivo de un
directorio a otro.
En la interface gráfica es muy posible que no dispongamos en nuestro gestor de archivos de una
opción mover. Esta opción en la interface gráfica suele ser “cortar” o “enviar a” .

5.4 Eliminar archivos y directorios

Eliminar archivos desde la linea de comandos se realiza con el comando rm (remove).

Para probar este comando vamos a crear un directorio llamado cantantes con mkdir.
$ mkdir cantantes
Nos meteremos dentro de cantantes con cd.
$ cd cantantes
Con pwd y con ls vamos a ver donde estamos y que archivos tiene cantantes en su interior.
Estaremos en /home/nuestrouser/cantantes/ y no tendremos archivos ni directorios en el interior del
directorio cantantes.
Creamos pues los siguientes archivos sin nada en su interior usando el comando touch:
$ touch Michael_Jackson.txt Bob_Marley.txt Bob_Dylan.txt James_Brown.txt John_lennon.txt
Una vez creados si hacemos un ls veremos los siguientes archivos:
Michael_Jackson.txt
Bob_Marley.txt
Bob_Dylan.txt
James_Brown.txt
John_lennon.txt
Es momento de practicar el comando rm. Vamos a borrar el archivo Michael_Jackson.txt
$ rm Michael_Jackson.txt
Es posible que nos avise de que se trata de un archivo vació . Escribiremos y y pulsaremos enter.
Una vez ejecutada esta orden realizaremos un ls para ver cuantos archivos nos quedan. Nos
quedarán los siguientes:
Bob_Marley.txt
Bob_Dylan.txt
James_Brown.txt
John_lennon.txt
Ahora queremos borrar del tirón todos los archivos que empiecen por Bob y para ello vamos a usar
lo que se llaman caracteres comodines.
Cuando queremos trabajar con varios archivos a la vez, tenemos que nombrarlos de alguna forma.
Por eso, se emplean caracteres comodines. Se llaman así porque pueden sustituir a un carácter o a
varios en los nombres de archivos. Los comodines que vamos a usar son:
• ?: representa cualquier carácter válido en el nombre de un fichero. Solo sustituye a uno de
ellos, aunque son acumulables.
• *: representa de 0 a n caracteres válidos en el nombre de un fichero.

Esto lo vamos a ver muy claro con el ejemplo de los archivos Bob_Marley.txt y Bob_Dylan.txt ya
que ambos empiezan por el mismo nombre. Bob
La forma por tanto de borrar todos los archivos del tirón es indicar esto en el comando rm usando
comodines.
$ rm Bob*
Esto borrará todo lo que comience con Bob. Esto eliminará por tanto los archivos indicandos
anteriormente. Podemos comprobarlo con un ls. Nos quedan 2 cantantes por cepillarnos:
James_Brown.txt
John_lennon.txt
Vamos a copiar James_Brown.txt 2 veces llamándose así las copias:
James_Brown2.txt
James_Brown3.txt
Para ello usaremos el comando cp que hemos comentado antes.
$ cp James_Brown.txt James_Brown2.txt
$ cp James_Brown.txt James_Brown3.txt
Si realizamos un ls vamos a ver que existen estos nuevos archivos.
Ahora vamos a borrarlos y para ello vamos a practicar el comodín ? Tanto para borrar como para
listar con ls.
Primero hacemos un ls para mostrar solamente los archivos copiados.
$ ls James_Brown?.txt
Nos salen solamente 2 archivos. No sale James_Brown.txt pero si salen las copias.
Para ahora borrar los archivos copia usaremos el mismo comodín pero en el comando rm.
$ rm James_Brown?.txt
Hacemos un ls y nos quedarán de nuevo los mismos archivos que antes. Vamos a borrarlos todos
así:
$ rm *
Eso eliminará todos los archivos del directorio actual independientemente de lo que contengan.
Ahora vamos a salir de este directorio y regresar a nuestro home.
$ cd /home/nuestrousaurio
Con esa orden, si cambiamos nuestrousuario por el nombre del usuario que estamos usando (que
podemos ver usando whoami) accederemos al directorio de nuestro usuario en el sistema.
Es momento de poner orden. Vamos a borrar el directorio recetas.
$ rm recetas
Nos indicará que no puede ser eliminado ya que es un directorio. Para ello hemos de utilizar los
argumentos -rf
$ rm -rf recetas
Esto es buena cosa. Con el argumento -r le indicamos que queremos borrar recursivamente incluso
directorios (no solamente archivos) y con el argumento f indicamos que fuerce sin darnos la brasa
preguntando.
Hacemos lo mismo con el directorio recetas2 y con el resto de archivos que tengamos por allí
pululando.
La finalidad es que haciendo un simple ls no veamos finalmente nada.
Ya sabemos borrar.
 006. Archivos ocultos e historial

6.1 Archivos ocultos.

6.2 Historial.

6.1 Archivos ocultos

En linux y de hecho en cualquier sistema unix-like (basados en unix) los archivos ocultos se crean
anteponiéndoles un punto “.” en el nombre, de ésta forma si exploramos la carpeta donde creamos
ese archivo que inicia con un “.” no lo encontraremos.
¿Cómo ver los archivos ocultos?
Fácil, si nos encontramos en la consola lo único que tenemos que hacer es ejecutar el comando “ls
-a” al ejecutarlo veremos muchos archivos que tienen un “.” antecediendo su nombre.
$ ls -la
¿Cómo crear archivos ocultos?
Bueno, ésto ya lo he comentado, simplemente anteponemos un “.” (sólo el punto) al nombre del
archivo y con ésto será suficiente, habremos creado un archivo oculto, y lo mismo se aplica para
crear directorios ocultos.
¿Cómo hacemos que un archivo deje de ser oculto?
Más fácil aún, simplemente quitamos el punto que antecede a su nombre y con eso queda listo.
Esto nos lleva a saber renombrar archivos.
Para esto vamos a crear primero usando el editor de texto nano 1 archivo oculto con el nombre
.enlaces.txt

$ nano .enlaces.txt
Escribimos varias urls de webs que nos gusten una por cada linea, guardamos (control + o) y
salimos (con control + x).
$ ls
Si hacemos un ls no veremos el archivo. Esta oculto.
Si realizamos un ls -la si que vamos a verlo.
$ ls -a
Cuando hemos realizado el ls -a el archivo si se ha mostrado. Esto es como en la intefaz gráfica en
gestores como nautilus. Si en un gestor gráfico como nautilus pulsamos control + h veremos los
archivos ocultos y si pulsamos control + h de nuevo se ocultarán.
Ya sabemos por tanto que para ocultar un archivo simplemente le añadiremos un punto
delante del nombre.

6.2 Historial.

El historial de los comandos que vamos escribiendo se va guardando en un fichero de texto oculto
en nuestro home. Ese fichero se llama .bash_history
Nosotros estamos usando la shell bash de modo que es así cuando usamos bash. Si usamos otro
interprete de comandos esto cambiará.
Veamos los últimos comandos que hemos escrito usando el editor de texto que ya conocemos: nano.
$ nano .bash_history
Es importante conocer la tecla tabulador ya que nos va a ayudar mucho a auto-completar.

Si escribimos nano .bash y luego pulsamos tabulador varias veces veremos que nos salen los
archivos que empiezan por .bash y veremos por tanto el nombre completo de estos.
Si escribimos nano .bash_h y luego pulsamos tabulador se auto-completa el nombre del archivo.
Para visualizar el contenido de un archivo no es necesario usar realmente nano. El comando cat nos
servirá igualmente para esta tarea. No vamos a ver aún este comando. Paciencia.
Escribiremos el comando history:
$ history
Y veremos que sale un listado de los comandos anteriores que hemos estado empleando.
Si hacemos la prueba escribiendo incluso comandos que no existan como por ejemplo “mierda”
“perro” “gato” y luego escribimos history veremos que se registran en el archivo de historial.
Podemos hacer uso rápidamente de los anteriores comandos simplemente usando los cursores.

Usaremos la tecla de la flecha apuntando hacia arriba para ir viendo los comandos anteriores y la
tecla de abajo para ver los comandos posteriores.
De esta forma muchas veces nos ahorramos tener que escribir algo otra vez pudiendo incluso
modificar la linea que nos salga para ejecutarla con alguna variante.
Esto es posible gracias a que se guarda un historial de los comandos por cada usuario del
sistema incluido el usuario root.
Si no deseamos que un comando se registre en el historial le meteremos un espacio delante.
Hagamos la prueba con varios comandos metiendo siempre un espacio delante y luego con history
miraremos el historial.
Con conocer esto es suficiente pero podemos ampliar algo más.
Existe una variable de sistema que se encarga de indicar el formato que tendrá la salida del
comando history
Ahora mismo no hace falta saber que son las variables de sistema pero es bueno saber que existen
muchas y que son necesarias.
Vamos a usar el comando echo para conocer el contenido de algunas de las variables importantes.
$ echo $SHELL
Eso nos indicará que tipo de shell estamos usando. En nuestro caso será bash.
$ echo $BASH
Visualizando el contenido de esa otra variable veremos lo mismo.
$ echo $BASH_VERSION
Con esto vamos a ver la versión del interprete de comandos que estamos usando.
4.2.37(1)-release es la nuestra. Si actualizásemos a una versión más reciente de bash saldría otro
numerito.
Podemos ver que existen otros interpretes de comandos en el sistema aparte de bash. Esto podemos
verlo mirando en el fichero /etc/shells
$ cat /etc/shells
/bin/sh
/bin/dash
/bin/bash
/bin/rbash
/usr/bin/screen
Veremos algo como eso. Eso indica que aparte de bash que es el interprete que usamos existen otros
que pueden usarse. No vamos a entrar ahora mismo en detalles pero si fijarnos que estos programas
están en el directorio /bin/ e incluso en otros como /usr/bin/ en el caso del interprete screen.
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
La variable $PATH de sistema indica donde estan los programas, es decir, cuando ejecutamos una
orden busca que estas estén en esos directorios y que nuestro usuario tenga permisos para ejecutar la
orden.
Esto nos lleva por tanto a conocer que gracias a que /bin/ y /usr/bin entre otras rutas o directorios
están en la variable de sistema $PATH es posible ejecutar muchísimos comandos y ordenes ya que
son programas que están en esos directorios.
Cuando ejecutamos la orden ls en realidad estamos ejecutando el programa ls que esta en el
directorio /bin/
Seria lo mismo por tanto ejecutar el comando así:
$ /bin/ls
Sin entrar en muchos más detalles simplemente hemos de entender que si un comando se ejecuta
cuando lo escribimos es que esta en uno de esos directorios o bien es un comando interno de la shell
que estamos empleando.
Algunos comandos como history por ejemplo no están en ningún directorio de los especificados
en la variable $PATH . Son comandos internos que vienen con bash.
Algunos otros comandos internos son exit por ejemplo. Exit es un comando que nos sirve para
cerrar la sessión del usuario que estamos usando.
Con saber que history no lo encontraremos por tanto en ningún directorio es suficiente.
Y con saber que existe una variable para configurar la salida de history vamos a poder saber cosas
como cuando se ha ejecutado un comando.
Por defecto history nos muestra una salida numerada de los comandos que hemos introducido pero
puede incluso mostrar más detalles.
Para ello vamos a modificar la variable $HISTTIMEFORMAT así:
$ export HISTTIMEFORMAT='%F %T '
Si ahora ejecutamos history veremos que la salida es diferente y nos muestra mucha más
información.
296 2015-01-12 12:58:19 clear
297 2015-01-12 12:58:22 mierda
298 2015-01-12 12:58:24 history
299 2015-01-12 13:03:42 ls
Esto es importante algunas veces pero ahora mismo simplemente nos sirve como curiosidad.
Cuando aprendamos algunos comandos más esto puede ser de utilidad para poder filtrar lo que
hemos escrito hace varios días.
Vamos con fc.
El comando fc (fix command) es un clásico del C Shell traído al mundo de Bash.
$ fc
Este comando nos sirve para cambiar un comando en el historial. Nos permite editarlo y guardarlo
para de esta forma si nos hemos confundido poder tenerlo a mano sin tener que teclearlo de nuevo.
Esto sirve para comandos largos sobre todo. Para algo muy corto no merece la pena.
$ fc -l
Con ele como argumento veremos una lista de los últimos comandos y su número correspondiente
en el historial. Esto funciona como history y puede usarse muchas veces ya que es más corto de
escribir.
Si deseamos alterar del historial un comando determinado y conocemos su número identificativo
podemos especificarlo.
$ fc -22
Eso nos abrirá el editor nano y nos permitirá editar y guardar (control+o) y luego salir (control+x).
El motivo de que abra nano y no otro editor es que este esta definido en la variable de sistema
$EDITOR . Podemos por tanto especificar allí otro si lo deseamos.
$ EDITOR="emacs"
si hacemos un echo $EDITOR vamos a ver que esta definida. Si ejecutamos ahora fc veremos que
se abre con emacs en vez de con nano.
 007. Concatenar archivos

7.1 El comando echo y clear

7.2 El famoso comando cat

7.1 El comando echo y clear

En MSDos la gente usaba el comando cls. Aún sigue pudiéndose usar en sistemas operativos
privativos como Windows desde el interprete de comandos que cmd que este incorpora.
Cls en GNU/Linux es clear y sirve para hacer limpieza de lo que estamos viendo en el terminal.
$ clear
Sin darnos cuenta vamos a usar este comando mucho. Cuando queremos una salida limpia sin que
interfiera a la vista.
El comando echo nos servirá para mostrar en pantalla algo. Ese algo puede ser una variable de
sistema como por ejemplo $PATH
$ echo $PATH
O podemos usarlo para mostrar un texto como por ejemplo “hola”
$ echo hola
Veremos que se mostrará hola en pantalla. Si queremos mostrar hola mundo podemos hacerlo
poniendo el texto entre comillas.
$ echo “hola mundo”
Dependiendo de la versión de echo que estemos usando esto puede variar. No obstante meter entre
comillas los textos con palabras separadas es buena cosa.
Podemos mostrar un texto y luego el contenido de una variable:
$ echo “la version de bash es $BASH_VERSION”
La salida será algo como esto: la version de bash es 4.2.37(1)-release
Esto da juego a crear nuestras propias variables. Podemos poner en una variable que nos
inventemos un contenido, por ejemplo en una variable llamada nombre meteremos nuestro nombre.
$ nombre="Fanta"
en otras variables vamos a meter nuestro apellido.
$ apellido1="De"
$ apellido2="Naranja"
Ahora con echo vamos a mostrar nuestro nombre completo
$ echo “Mi nombre es $nombre y mis apellidos son $apellido1 $apellido2”
La salida será algo como esto: Mi nombre es Fanta y mis apellidos son De Naranja
Podemos borrar/limpiar con clear la pantalla para tenerla bien limpia y lista para meter más
comandos.
Aparte de texto echo puede servirnos para emitir un pitido. Lo que suele llamarse un beep por el
altavoz interno de nuestro ordenador.
Estamos en un servidor de modo que no vamos a escuchar el pitido no obstante es bueno saberlo.
Esto se realiza usando “backslash escapes” que son unas barritas como \n para nueva linea \a para
emitir un pitido \t para un tabulado horizontal, etc...
Para activarlo se usa el argumento -e y con eso indicamos que queremos que echo interprete.
$ echo “$nombre\n$apellido1\n$apellido2”
Mostrará el nombre y apellidos cada uno en una linea diferente:
Fanta
De
Naranja
Con saber esto nos basta y sobra.
Posiblemente ahora no encontremos muchos usos a echo pero para eso estamos. Ahora después
veremos algunos.

7.2 El famoso comando cat

Hasta este momento hemos estado utilizando un editor de textos para introducir texto dentro de
archivos. Es una forma muy cómoda de hacerlo pero hemos de saber que no es la única.
Con un echo vamos a poder introducir texto dentro de un archivo y por tanto vamos a recordar
algunos comandos que hemos usado.
tocuh – Nos estaba sirviendo y sigue sirviendo para crear archivos sin nada en su interior.
echo – Nos sirve para mostrar texto en pantalla. La pantalla es la salida standard.
Cuando ejecutamos un comando y pulsamos intro este va a escupir la salida por lo que se llama la
salida standard. Esta salida es la pantalla y por tanto si por ejemplo realizamos un ls -ls para ver los
archivos estos saldrán impresos en pantalla.
Podemos variar por donde queremos que salga escupida la salida.
Al ejecutar echo “hola mundo” nos salia el texto por la pantalla pero podemos hacer que en vez de
salir por pantalla este se guarde en un fichero.
Vamos a crear un archivo llamado texto.txt con touch.
$ touch texto.txt
Ahora vamos a usar cat para ver que contiene en su interior.
$ cat texto.txt
La salida por pantalla no va a contener nada pero si usamos echo para volcar el contenido en ese
archivo si que vamos a ver algo cuando luego usemos cat.
$ echo “hola mundo” > texto.txt
Lo que acabamos de hacer es redireccionar la salida del comando echo “hola mundo” para que se
escriba en el archivo texto.txt sobrescribiendo cualquier cosa que tenga en su interior. En nuestro
caso no es un problema ya que estaba sin nada dentro.
$ cat texto.txt
Con el comando cat vamos a ver que contiene y veremos que efectivamente el contenido se ha
volcado con éxito.
Si ahora volcamos de nuevo con un echo otra frase como por ejemplo “adios mundo” veremos que
se sobrescribe el contenido del archivo por el nuevo.
$ echo “adios mundo” > texto.txt

En esa captura puede verse con claridad.

Lo cierto es que no era necesario usar touch para crear el archivo primero.
Si ahora queremos guardar nuestro nombre en otro fichero llamado nombre.txt podemos hacerlo sin
necesidad de crearlo primero.
$ echo “fanta” > nombre.txt
Se creará si no existe. En caso de existir se sobreescribe.
Si deseamos no sobrescribir el archivo y simplemente añadirle más lineas usaremos >> en vez de >
$ echo “benito” >> nombre.txt
Si hacemos un cat al archivo nombre.txt veremos que ahora existen 2 lineas y 2 nombres.
Pero cat no es solamente para ver un archivo.
El comando cat nos permite concatenar el contenido de diferentes archivos o visualizar el de ambos.
$ cat nombre.txt texto.txt
De esta forma podemos ver el contenido de ambos ficheros del tirón.
Fanta
benito
adios mundo
Eso será la salida que se mostrará.
Podemos volcarla como ya sabemos a un nuevo fichero llamado juntos.txt
$ cat nombre.txt texto.txt > juntos.txt
Si ahora hacemos cat al fichero juntos.txt vamos a ver el contenido junto.
Hemos unido por tanto 2 ficheros. Podemos hacer esto usando los comodines así:
$ cat *.txt > juntos.txt
Se sobrescribirá el fichero juntos.txt con el contenido de todos los archivos con extensión .txt que
tengamos en el directorio.
Y cat tiene muchas más opciones de las que por ejemplo nos puede interesar ver la salida de un
archivo con las lineas numeradas.
$ cat -n juntos.txt
Veremos algo así como esto:
1 fanta
2 benito
3 adios mundo
Lo cual nos sirve para entre otras cosas saber en que linea esta algo sin necesidad de usar un editor
de textos como nano.
 008. Tuberías

8.1 Historia del perro echo y el perro wc

8.2 More, head y tail

8.1 Historia del perro echo y el perro wc

Es posible redirigir la salida estándar de un programa a la entrada estándar de otro usando el

operador | (pipeline).
Las pipes o tuberías son algo que añade mucha potencia al trabajo en la línea de comandos.
Para entenderlo tenemos que pensar que los programas son como seres humanos que tienen una
boca por donde comen y un culo por donde cagan.
Un programa obtiene una serie de datos por la boca normalmente y somos nosotros quienes
mediante el teclado les damos de comer.
Una vez digieren y procesan lo que le hemos dado lo cagan por el culo.

Un ejemplo sencillo para entenderlo es usar el comando echo y el comando wc (que viene un poco
a cuento de todo el tema este de cargar).
$ echo “hola” | wc -c
el comando wc nos sirve para contar. En este caso con -c estamos indicando que queremos contar
caracteres.
Alimentamos al perro llamado echo que es el programa echo. Lo alimentamos con la palabra hola y
se lo damos por la boca.
El perro echo lo que hace es digerir lo que le hemos entregado y lo caga por el culo. Si no
tuviéramos entubado al otro perro llamado wc justo en su culo la salida seria por pantalla.
Cuando colocamos | (escrito usando altgr + 1) lo que hacemos es variar la salida para que sea la
entrada de otro programa.
Hemos colocado al perro wc justo para que pueda comerse lo que el perro echo ha cagado.
El perro wc va a digerir la mierda del perro echo y la procesará. Su organismo es distinto y por
tanto sacará otro resultado.

En este caso el perro wc no tiene a otro perro lamiendo el trasero de modo que cagará el resultado y
en este caso será un 4.
Hemos conseguido por tanto variar la salida para dársela a otro programa. Para esto es para lo que
se usan las tuberías.
Espero no sea esto algo muy explicito y sirva para entender el funcionamiento.
De esta forma y con los comandos que ya conocemos podemos entubar algunos para obtener otras
informaciones.
¿Cuantas sesiones de usuarios tenemos en el sistema?
El comanod who nos servia para esto.
$ who
Una vez ejecutado vemos que existen varias lineas y cada una de ellas le pertenece a un usuario o a
una sesión de usuario mejor dicho.
El comando wc nos sirve para contar. En este caso queremos contar lineas y si hacemos un who
veremos que salen varias lineas.
Con wc -c contamos caracteres y con wc -l contamos lineas.
$ who | wc -l
Eso nos dará el número de sesiones de usuario en el sistema.
Entubar sirve para mucho por lo que vemos. Cuando conozcamos más comandos como por ejemplo
grep, cut, tr, … vamos a poder realizar muchas otras tareas de forma muy sencilla combinando
programas gracias a las tuberías.
Nos convertiremos rápidamente en super mario. Un gran fontanero.

8.2 More, head y tail

Uno de los usos más normales de tuberías es redirigir la salida del programa cat a la entrada del
programa more.
Si disponemos de un texto largo y lo visualizamos con cat este no va a verse bien.
Un ejemplo para ver esto en el servidor es el fichero passwd que estará dentro del directorio de
sistema /etc/
$ cat /etc/passwd
Realizando eso nos saldrán muchas lineas pero si lo entubamos hacia el programa more este nos va
a permitir ir viéndolas poco a poco.
$ cat /etc/passwd | more
Por tanto cat entubado con more son algo muy usado.
Supongamos ahora que queremos solamente visualizar las primeras 10 lineas de ese archivo. En
este caso vamos a “entubarlo” a otro programa llamado head que nos permitirá cortar y solo
mostrar esas lineas.
$ cat /etc/passwd | head -10
Para verlo claro podemos hacer un clear antes de ejecutar esa orden.
Ahora vemos que salen menos resultados. Podemos comprobar que realmente son 10 lineas si
entubamos un nuevo programa a la salida de head. El programa wc con el argumento -l
$ cat /etc/passwd | head -10 | wc -l
¿Es una maravilla verdad? Nos ha contado la salida y la hemos filtrado previamente.
Si en vez de querer las primeras 10 lineas quisiéramos las últimas 10 utilizaríamos tail.
$ cat /etc/passwd | tail -10
¿Es fascinante verdad?
De forma muy rápida somos capaces de ir viendo lo que queremos en un fichero.
Aún no somos capaces de sacar solamente lo que queremos pero si que vamos conociendo algunas
herramientas que ya nos permiten ciertas cosas.
No nos olvidemos de que las salidas podemos volcarlas a otros ficheros.
Por defecto saldrán por la salida estándar que es el teclado pero podemos volcarlas a un archivo en
nuestro home.
$ cat /etc/passwd | tail -10 > /home/nuestrousuario/salida.txt
Hemos de sustituir “nuestrousuario” por el nombre de nuestro usuario. Si no nos acordamos usamos
whoami
Si tratamos de volcarlo en el directorio de otro usuario no vamos a poder ya que no tenemos
permisos de escritura allí. Solamente vamos a poder escribir en nuestro directorio de usuario dentro
de /home/ y en /tmp/ a sabiendas de que el contenido dentro del directorio /tmp/ se borrará cuando
se reinicie la maquina.
 009. Ayuda

9.1 La ayuda en la línea de comandos

9.1 La ayuda en la línea de comandos

La mayoría de los programas y aplicaciones (ejecutables desde la shell) incluyen gran número de
opciones y argumentos, con la consiguiente desventaja de la dificultad de recordar todos y cada
uno de ellos.
No podemos por tanto olvidar que siempre vamos a tener un manual de la mayoría de los programas
para linea de comandos, sobre todo de las GNU/ core utils.
La web con los man es esta: http://www.tldp.org/manpages/man.html
De todos modos los manuales vienen ya en prácticamente cualquier distro.
Para ejecutar y ver un manual de algún programa hemos de escribir man y luego el nombre del
programa. Ejemplos:
$ man nano
$ man man
$ man cat
$ man echo
Para salir del manual pulsamos la tecla “q” (que viene de quit en inglés, salir en castellano).
Algunos ejemplos de programas que no tienen manual.
$ man alias
$ man fc
No tienen manual ya que se trata de comandos internos de bash. En vez de un man lo que tienen es
un help.
Para ver por tanto la ayuda de estos comandos usaremos help:
$ help alias
$ help fc
No tiene mucho misterio esto. Luego aparte de estos manuales encontraremos que cada programa
suele llevar ayuda.
Por ejemplo el programa cat o el programa ls.
Si les añadimos el argumento -- help entonces vamos a poder ver ayuda de este programa.
$ ls --help
El manual suele llevar más información y más detallada. El argumento help nos mostrará
normalmente un resumen.
 010. Conocer nuestro sistema

10.1 Mostrar la arquitectura de la maquina

10.2 Información sobre el microprocesador
10.3 El directorio /proc/
10.4 Herramientas para monitorizar el sistema

10.1 Mostrar la arquitectura de la maquina

La arquitectura de computadoras es el diseño conceptual y la estructura operacional fundamental de

un sistema de computadora. Es decir, es un modelo y una descripción funcional de los
requerimientos y las implementaciones de diseño para varias partes de una computadora, con
especial interés en la forma en que la unidad central de proceso (cpu) trabaja internamente y accede
a las direcciones de memoria.
Es importante saber la arquitectura de nuestro equipo para instalar software que funcione en esta
arquitectura.
El comando para saber esto es arch.
$ arch
Pero podemos utilizar también uname con el argumento -m
$ uname -m
Siendo uname -a una forma de ver bastantes datos del tirón:
$ uname -a

10.2 Información sobre el microprocesador

Para ver la cpu de nuestra maquina así como información detallada usaremos 2 comandos.
$ lscpu
También podemos utilizar cat para obtener más información.
$ cat /proc/cpuinfo
Ahora explicaremos el motivo por el que es especial el directorio /proc/ y su contenido.
10.3 El directorio /proc/

El directorio /proc es una bestia extraña. Realmente no existe, sin embargo puedes explorarlo. Sus
archivos de tamaño 0 no son ni binarios ni textos, sin embargo puedes examinarlos y desplegar su
contenido. Este directorio especial contiene todos los detalles de tu sistema Linux, incluyendo el
kernel, procesos y parámetros de configuración. Estudiando el directorio /proc, puedes aprender
como los comandos de Linux trabajan e incluso es posible realizar tareas administrativas.
Bajo Linux, todo es administrado como un archivo; incluso los dispositivos son accedidos como
archivos (en el directorio /dev). Aunque que podrías pensar que archivos "normales" son ya sea
texto o binarios (o posiblemente dispositivos o archivos pipe), el directorio /proc contiene una
extraño tipo de archivo: archivos virtuales. Estos archivos son listados, pero realmente no existen en
disco; el sistema operativo los crea al vuelo si tratas de leerlos.
La mayoría de los archivos virtuales siempre tienen una marca de tiempo (timestamp) actual, lo que
indica que están constantemente siendo actualizados. El directorio /proc en si mismo es creado
cada vez que arrancas tu equipo. Se requiere ser root para poder examinar completamente el
directorio en su totalidad; algunos de los archivos (tales como los relacionados a procesos) son
propiedad del usuario que los ejecutó. Y aunque casi todos los archivos son de solo lectura, hay
algunos pocos con permisos de escritura (notablemente en /proc/sys) que permiten realizar cambios
en los parámetros del kernel. (Queda claro que debes ser muy cuidados con esto)
Si nos fijamos y hacemos un ls -la en la raíz del sistema veremos que ocupa 0.
$ cd /
$ ls -la
El directorio /proc está organizado en directorios virtuales y subdirectorios.
Si hacemos un ls al directorio /proc veremos algunos directorios (directorios virtuales) con nombres
de números. Esos directorios llevan el nombre identificativo de los procesos que se estan ejecutando
en el sistema.
Luego veremos eso con detenimiento.
Lo importante es que encontraremos allí información de sistema que nos viene bien y podemos
leerla como usuarios sin privilegios.
Para ver información relativa a la cpu hemos dicho que con:
$ cat /proc/cpuinfo
Para ver información sobre el tiempo que lleva encendido el ordenador podemos usar el comando
uptime.
$ uptime
Pero al mismo tiempo podemos usar también cat así:
$ cat /proc/uptime
En este caso veremos dos números: por cuantos segundos tu sistema ha estado encendido, y cuantos
segundos ha estado inactivo.
Hemos visto antes que con uname -a podemos ver mucha información relativa a la maquina.
Información resumida.
$ uname -a
Si visualizamos el directorio virtual /proc/version veremos lo mismo
$ cat /proc/version
Nos interesa lo mismo conocer la carga promedio del procesador. Esto lo vemos en /proc/loadavg
$ cat /proc/loadavg
Se trata de un archivo virtual que muestra la carga promedio del procesador; su información incluye
el uso de CPU en el último minuto, últimos cinco minutos y últimos 15 minutos, así como el
número de procesos actuales ejecutándose.
Existen más archivos y cada uno tiene muchas peculiaridades e información que nos puede resultar
de utilidad para conocer nuestro sistema no obstante veremos uno más y pasaremos a ver
herramientas que nos permiten ver todo esto de forma más clara y sencilla.
$ cat /proc/meminfo
Con eso veremos información sobre la memoria del sistema.

10.4 Herramientas para monitorizar el sistema

Estas herramientas son las siguientes: top, free y htop

Existen muchas más pero estas nos ayudarán a obtener rápidamente información relativa a nuestro
sistema en tiempo real.
Pueden probarlas y en el caso de top y htop podréis salir de ellas usando la tecla q.
Existe más información sobre el uso de estas herramientas si miráis el man.
Sobre htop hemos de comentar que es como top pero más potente y vistoso. Es posible que no lo
tengáis por defecto en vuestro sistema pero podréis instalarlo.
 011. Procesos

11.1 ¿Que es un proceso? Y tipos de procesos

11.2 Dejando huérfanos procesos.

11.1 ¿Que es un proceso? Y tipos de procesos

Un proceso simplemente es un programa en ejecución. Los procesos ademas de la información

propia del programa contienen la información necesaria para que el programa interaccione con el
sistema.

Podemos ver los procesos en el sistema usando ps

$ ps -A
Con eso vamos a ver algo muy limitado. Si le añadimos algunos argumentos más veremos más
información.
$ ps -eafw
Esto nos dará más información sobre los procesos.
Veamos ahora los tipos antes de practicar algo.

Child (hijos)
Un proceso hijo es un proceso creado por otro proceso, estos se crean mediante la llamada al
sistema fork() y en realidad, todos los procesos en algún momento son hijos, todos menos el
proceso init. En el caso de que un proceso sea creado mediante la shell ( ejecutado desde esta ), la
shell sera el padre.

Orphan (huérfanos)
Normalmente un proceso hijo termina antes que un proceso padre, pero se puede dar la situación de
que se mate a un proceso padre ( killed ) y el hijo se quede sin padre ( que crueldad ). Entonces el
proceso init lo adoptara como hijo, pero como su padre original no existe, es considerado huérfano.

Daemon (demonios)
Es un tipo especial de proceso que se ejecuta en segundo plano y no esta asociado a ninguna shell.
Esto se consigue matando la shell que crea el proceso, de esta forma el padre de este proceso pasa a
ser el proceso init ( queda huérfano ). Estos corren con permisos de root y su cometido es proveer
servicios a otros procesos.
Zombie
Cuando un proceso hijo termina, el sistema guarda el PID ( Identificador ) y su estado ( un
parámetro ) para dárselo a su padre. Hasta entonces el proceso finalizado entra en estado zombie.
Cuando un proceso finaliza toda la memoria y recursos asociados con dicho proceso son liberados,
pero la entrada del mismo en la tabla de procesos aún existe, para cuando su padre llame a la
función wait() devolverle su PID y estado.

Podemos usar top y ps para ver pero posiblemente nos interese conocer la herramienta pstree.
Esta herramienta nos servirá para ver los procesos en modo árbol.
$ pstree
Esto es bonito pero no muy detallado. Para obtener algo más de información (el PID y el PPID)
usaremos pstree -p
$ pstree -p
Ahora veremos el id del proceso, es decir, el PID y el id del proceso padre (el PPID).
Todos los procesos manan de otro anterior y todos los procesos tienen de padre a init. Es el proceso
1 del sistema y se generará siempre al iniciar el sistema.

11.2 Dejando huérfanos procesos.

Para realizar esto vamos primero a aprender a matar procesos y a dejarlos en segundo plano.
El comando sleep simplemente nos servirá para mantener un espacio de tiempo bloqueada la shell.
$ sleep 4
Si lo ejecutamos durante 4 segundos no vamos a poder introducir comando alguno.
No obstante podemos dejarlo 40 segundos en background y poder seguir metiendo comandos.
Para realizar esto con cualquier programa añadiremos & al final del comando. Ejemplo:
$ sleep 40&
Nos retornará el PID de ese proceso.
Si ahora hacemos un ps -eafw vamos a ver que sigue estando allí y si realizamos un pstree -p
veremos su PID y su PPID. Su PPID será bash en nuestro caso.
Podemos matar ese proceso ya que nos corresponde, es decir, lo hemos creado con nuestro usuario.
No vamos a poder matar los procesos de otros usuarios a no ser que seamos el usuario root.
Para matar un proceso bien matado usaremos kill mandando la señal -9
Más información sobre las señales la podremos ver con help kill o con kill -l
$ kill -9 numerodeproceso
Cuando hemos dejado en background el proceso nos ha retornado su PID. De esta forma matarlo
será simplemente indicarle a kill que proceso queremos matar.
Hagan la prueba y maten el proceso sleep indicando el PID que ha retornado.
Ahora vamos a dejar huérfano un proceso.
Para ello vamos a hacer login como otro usuario. Para esto usaremos su. Si no indicamos el nombre
de ningún usuario por defecto se tratará de hacer login como root.
El usuario root es el usuario que tiene permisos para hacer cualquier cosa en el sistema y por tanto
podrá matar los procesos de otros usuarios.
En nuestro caso lo que tenemos que hacer es hacer login con otro usuario y ejecutar un sleep 300&
De esa forma dejaremos el proceso sleep que durará 300 segundos vivo.
Durante ese tiempo vamos a visualizar los procesos y matarlo si disponemos de acceso como root.
En nuestro caso no es así pero veremos que se puede hacer.

Esto podéis practicarlo en vuestro propio sistema con vuestra cuenta de root.
El resultado será que el proceso dejará de tener un padre. El padre muere ya que lo matamos
nosotros como root.
El proceso hijo pasa a ser adoptado por init (proceso padre de todos) y sigue vivo pero ya no tiene
padre.
Que pena.
 012. Comunicación con otros usuarios y apagado

12.1 Apagar y reiniciar la maquina.

12.2 Alone in the shell

12.1 Apagar y reiniciar la maquina

La maquina podemos apagarla usando shutdown.

Esto supone un problema si la maquina no esta físicamente cerca de ti, es decir, lo mismo si la
apagas tienes que luego ir a encenderla o llamar para que alguien lo haga.
Por suerte los servidores permiten encendido remoto y esto permite que podamos apagar maquinas
y encenderlas desde paneles de control web y otras formas.
Una forma de apagar inmediatamente es esta:
$ shutdown -h 0
Para reiniciar usaremos reboot.
$ reboot
Con saber esto es suficiente.

12.2 Alone in the shell

No estas solo en la shell. Puedes enviarte mensajes con otros usuarios en tiempor real.
Para ello tenemos que activar o desactivar la posibilidad.
Esto se hace con mesg.
$ mesg
Si mesg suelta un “y” eso significa yes. Estamos permitiendo mensajes a nuestro usuario.
Si mesg suelta un “n” eso es no. Podemos por tanto indicar con mesg si queremos que nos puedan
mandar mensajes o si no lo deseamos.
$ mesg n
$ mesg y

Mandar un mensaje a todo el mundo se realiza usando la cuenta de root. El administrador de

sistemas por tanto puede usar el comando wall para colocar en el muro de todos los usuarios del
sistema un mensaje.
$ wall
Una vez escrito el mensaje se pulsa control+D y se enviará.
Esto es un mensaje de broadcast y les llegará a todos los usuarios del sistema. Sirve para avisar de
un reinicio por ejemplo o de cualquier cosa que pueda afectarles.
La comunicación entre usuarios se puede realizar con write o con talk.
Con write primero escribes y luego mandas y con talk la comunicación es en tiempo real, se va
viendo todo lo que escribes.
$ write nombreusuario
Con eso mandamos mensajes a un usuario determinado y le aparecerán de repente una vez
puldamos intro.
Para parar usamos control+C
Talk es más educado y permite comunicarse como si fuese un chat.
$ talk nombreusuario@tallerlinux pts/x
Con esto le mandamos una petición a un usuario. Usando who vamos a poder ver su nombre de
usuario y su tty.
El usuario tendrá que escribir lo que le llega y de esa forma se establece la comunicación.
 013. Permisos

13.1 Entendiendo los permisos

13.2 Chmod

13.1 Entendiendo los permisos

Antes de nada vamos a realizar un ls -l en nuestro home.

$ ls -l
En la primera columna vamos a ver algo como esto para cada archivo.
drwxr-xr-x 2 fanta fanta 4096 ene 12 20:37 directorio/
-rw-r--r-- 2 fanta fanta 52 ene 12 20:40 hola.txt
Ahora es importante fijarse en este dibujo:

El primer espacio será para indicar el tipo de archivo.

Los tipos de archivo pueden ser:
- Un guión representa un archivo común (de texto, html, mp3, jpg, etc.)
d Significa que se trata de un directorio.
l Significa que se trata de un enlace (un acceso directo).
b Significa que se trata de un binario. Un archivo ejecutable generalmente.

El resto de espacios son los permisos del archivo. Hemos de leerlos de 3 en 3.

Los primeros 3 son los permisos para el usuario, los otros siguientes 3 para el grupo y el resto para
el resto de usuarios.
Los valores posibles que podemos introducir en cada una de esas casillas son los siguientes

r Lectura (read)
w Escritura (write)
x Ejecución (execution)
Un archivo con el siguiente esquema ¿Que significará?
- rw- r-- r--
Entenderemos que se trata de un archivo común ya que la primera posición tiene un -
las siguientes tres posiciones tienen rw- de modo que intrepretamos que el usuario propietario de
ese archivo tiene permiso para leerlo y escribir.
Entendemos que tanto el grupo al que pertenezca el archivo como el resto de usuarios del sistema
solamente van a poder leer.
d rwx r-x r-x
Este caso es diferente. Indica que se trata de un directorio. Nuestro usuario puede leer, escribir y
ejecutar mientras que el grupo y otros solamente leer y ejecutar.
En esta tabla se ve más claro:
--- =0 no se tiene ningún permiso
--x =1 solo permiso de ejecución
-w- =2 solo permiso de escritura
-wx =3 permisos de escritura y ejecución
r-- =4 solo permiso de lectura
r-x =5 permisos de lectura y ejecución
rw- =6 permisos de lectura y escritura
rwx =7 todos los permisos establecidos, lectura, escritura y ejecución

Esas son todas las posibilidades existentes representadas cada una de ellas en base8.

El sistema numérico en base 8 se llama octal y utiliza los dígitos del 0 al 7.

En informática a veces se utiliza la numeración octal en vez de la hexadecimal. Tiene la ventaja de
que no requiere utilizar otros símbolos diferentes de los dígitos
En el caso de los permisos de este archivo:
- rw- r-- r--
Deducimos que es un archivo normal.
Y vamos a sustituir los 3 bloques por el número en octal de la tabla de arriba. Nos quedará esto:
644
Ese archivo podrá ser leído por otros usuarios del sistema pero solamente nosotros podemos leerlo y
escribir sobre él.

13.2 Chmod

El comando chmod nos va a permitir cambiarle los permisos a un archivo o directorio.

Algunos ejemplos:

rw------- 600 El propietario tiene permisos de lectura y escritura.

rwx--x--x 711 El propietario lectura, escritura y ejecución, el grupo y otros solo ejecución.
El propietario lectura, escritura y ejecución, el grupo y otros pueden leer y
rwxr-xr-x 755
ejecutar el archivo.
rwxrwxrwx 777 El archivo puede ser leído, escrito y ejecutado por quien sea.
Solo el propietario puede leer el archivo, pero ni el mismo puede modificarlo o
r-------- 400
ejecutarlo y por supuesto ni el grupo ni otros pueden hacer nada en el.
El usuario propietario puede leer y escribir, el grupo puede leer el archivo y otros
rw-r----- 640
no pueden hacer nada.

$ chmod 777 arhivo.txt

Si existe ese archivo que previamente podemos crear le cambiaremos los permisos para que
cualquiera pueda escribir, leer y ejecutar.
En el caso de querer que solamente unos usuarios del sistema puedan hacerlo tendríamos que crear
un grupo primero y llamarlo de alguna forma.
A ese grupo le añadiríamos usuarios.
Finalmente cambiaríamos el grupo al que pertenece el usuario con chown.
Esto es una labor más del administrador del sistema que nuestra como usuarios de modo que lo
dejaremos para que cada cual experimente en su propia maquina.
 014. Directorios de sistema

14.1 Los directorios de sistema más usuales

14.2 Crear un disco en la RAM

14.1 Los directorios de sistema más usuales

Cada distribución de GNU/Linux puede usar unos directorios de sistema u otros. De todos modos
suelen ser similares.
Existe un estandard, el "Estándar de jerarquía de ficheros" (FHS - Filesystem Hierarchy Standard)
que intenta definir unas bases, para que tanto los programas del sistema, como los usuarios y
administradores, sepan donde encontrar lo que buscan.
Este estandard se encuentra en su versión 2.3 y el documento del mismo se puede encontrar en su
totalidad en esta dirección: http://www.pathname.com/fhs/pub/fhs-2.3.html.
Se recomienda su lectura a los/las que deseen profundizar en el tema.
Para verlos vamos a movernos usando cd al directorio raiz del sistema.
$ cd /
Y vamos a realizar un ls -l para ver los diferentes directorios que allí se encuentran.
$ ls -l
Vamos a encontrarnos los siguientes en nuestro caso:
drwxr-xr-x 2 root root 4096 ene 12 15:18 bin/
drwxr-xr-x 2 root root 4096 dic 14 2012 boot/
drwxr-xr-x 3 root root 4096 ene 13 14:12 dev/
drwxr-xr-x 67 root root 4096 ene 13 19:59 etc/
drwxr-xr-x 89 root root 4096 ene 13 19:59 home/
drwxr-xr-x 9 root root 4096 ene 8 18:50 lib/
drwxr-xr-x 2 root root 4096 ene 7 15:07 lib64/
drwxr-xr-x 2 root root 4096 mar 10 2013 media/
drwxr-xr-x 2 root root 4096 dic 14 2012 mnt/
drwxr-xr-x 2 root root 4096 mar 10 2013 opt/
dr-xr-xr-x 27 root root 0 ene 13 14:12 proc/
drwx------ 5 root root 4096 ene 12 20:05 root/
drwxr-xr-x 10 root root 360 ene 13 14:15 run/
drwxr-xr-x 2 root root 4096 ene 7 15:07 sbin/
drwxr-xr-x 2 root root 4096 jun 10 2012 selinux/
drwxr-xr-x 2 root root 4096 mar 10 2013 srv/
drwxr-xr-x 7 root root 0 ene 13 14:12 sys/
drwxrwxrwt 4 root root 4096 ene 14 11:25 tmp/
drwxr-xr-x 10 root root 4096 mar 10 2013 usr/
drwxr-xr-x 11 root root 4096 mar 10 2013 var/
Veremos que existen muchos pero en especial hemos de fijarnos en 2 que tienen permisos de
sistema diferentes al resto.
/root y /tmp
Respecto al directorio /root hemos de tener en cuenta que es un directorio reservado al usuario root.
El usuario root es el usuario que puede realizar todo en el sistema. Para root no existen barreras
mientras que los usuarios normales del sistema si que van a tener problemas para editar archivos de
sistema o de otros usuarios.
Los usuarios normales del sistema tendrán su propio directorio dentro de /home/ y root tendrá su
propio directorio en /root .
El directorio root por tanto solamente será visible por el usuario root. Allí root almacena lo que
quiera.
/tmp es un directorio donde se almacenarán archivos o directorios temporales. Aquí pueden escribir
los usuarios normales del sistema sin problemas. El problema es que cuando se reinicia la maquina
el contenido de este directorio desaparece.
Quitamos del listado pues esos 3 directorios (/home , /root y /tmp) y seguimos explicando otros.
drwxr-xr-x 2 root root 4096 ene 12 15:18 bin/
drwxr-xr-x 2 root root 4096 dic 14 2012 boot/
drwxr-xr-x 3 root root 4096 ene 13 14:12 dev/
drwxr-xr-x 67 root root 4096 ene 13 19:59 etc/
drwxr-xr-x 9 root root 4096 ene 8 18:50 lib/
drwxr-xr-x 2 root root 4096 ene 7 15:07 lib64/
drwxr-xr-x 2 root root 4096 mar 10 2013 media/
drwxr-xr-x 2 root root 4096 dic 14 2012 mnt/
drwxr-xr-x 2 root root 4096 mar 10 2013 opt/
dr-xr-xr-x 27 root root 0 ene 13 14:12 proc/
drwxr-xr-x 10 root root 360 ene 13 14:15 run/
drwxr-xr-x 2 root root 4096 ene 7 15:07 sbin/
drwxr-xr-x 2 root root 4096 jun 10 2012 selinux/
drwxr-xr-x 2 root root 4096 mar 10 2013 srv/
drwxr-xr-x 7 root root 0 ene 13 14:12 sys/
drwxr-xr-x 10 root root 4096 mar 10 2013 usr/
drwxr-xr-x 11 root root 4096 mar 10 2013 var/
Si ahora hacemos un echo para mostrar el contenido de la variable $PATH veremos lo siguiente:
$ echo $PATH
/usr/local/bin /usr/bin /bin /usr/bin/X11 /usr/games
Si lo realizásemos como usuario root veríamos algún directorio más.
# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
Esto nos sirve para saber que el usuario normal no podrá ejecutar en un principio comandos como
shutdown ya que no esta en su variable $PATH.
/bin por tanto contendrá programas que pueden usar usuarios del sistema. Es donde se suelen meter
los programas que podrá ejecutar el usuario normal y también root.
/sbin es para el superusuario root.
Que un programa no este en nuestro $PATH como usuario normal del sistema no implica que no
podamos ejecutarlo.
Dentro de /sbin tenemos por ejemplo shutdown y reboot. Si tratamos de ejecutarlos así:
$ /sbin/reboot
$ /sbin/shutdown
No vamos a poder ejecutarlos ya que el programa dirá que no somos el usuario root.
Existe por tanto una diferenciación donde colocar determinados archivos que son solamente para el
usuario root y donde colocar los que pueden ser usados por el resto de usuarios del sistema.
Seguimos con otros directorios teniendo en cuenta que /proc/ ya lo conocemos y hemos hablado de
su peculiaridad anteriormente.
drwxr-xr-x 2 root root 4096 dic 14 2012 boot/
drwxr-xr-x 3 root root 4096 ene 13 14:12 dev/
drwxr-xr-x 67 root root 4096 ene 13 19:59 etc/
drwxr-xr-x 9 root root 4096 ene 8 18:50 lib/
drwxr-xr-x 2 root root 4096 ene 7 15:07 lib64/
drwxr-xr-x 2 root root 4096 mar 10 2013 media/
drwxr-xr-x 2 root root 4096 dic 14 2012 mnt/
drwxr-xr-x 2 root root 4096 mar 10 2013 opt/
dr-xr-xr-x 27 root root 0 ene 13 14:12 proc/
drwxr-xr-x 10 root root 360 ene 13 14:15 run/
drwxr-xr-x 2 root root 4096 jun 10 2012 selinux/
drwxr-xr-x 2 root root 4096 mar 10 2013 srv/
drwxr-xr-x 7 root root 0 ene 13 14:12 sys/
drwxr-xr-x 10 root root 4096 mar 10 2013 usr/
drwxr-xr-x 11 root root 4096 mar 10 2013 var/
El directorio /mnt y /media son para montar particiones con sistemas de ficheros que pueden ser
diferentes. Normalmente /mnt/ se usa para sistemas de ficheros montados temporalmente y /media/
para puntos de montaje de unidades de medios como pueden ser unidades de DVD/CD.
Para montar se usa el comando mount y para desmontar umount.
No entraemos en detalles pero evidentemente si andais interesados en conocer esto buscar.
Ya nos van quedando menos. Vamos a resumir los más importantes.
drwxr-xr-x 2 root root 4096 dic 14 2012 boot/
drwxr-xr-x 3 root root 4096 ene 13 14:12 dev/
drwxr-xr-x 67 root root 4096 ene 13 19:59 etc/
drwxr-xr-x 9 root root 4096 ene 8 18:50 lib/
drwxr-xr-x 2 root root 4096 ene 7 15:07 lib64/
drwxr-xr-x 2 root root 4096 mar 10 2013 opt/
drwxr-xr-x 10 root root 360 ene 13 14:15 run/
drwxr-xr-x 2 root root 4096 jun 10 2012 selinux/
drwxr-xr-x 2 root root 4096 mar 10 2013 srv/
drwxr-xr-x 7 root root 0 ene 13 14:12 sys/
drwxr-xr-x 10 root root 4096 mar 10 2013 usr/
drwxr-xr-x 11 root root 4096 mar 10 2013 var/

/var se usa para archivos variables. Logs, bases de datos, directorios de servidores HTTP y FTP,
colas de correo, …
/etc/ es donde se almacenan los archivos de configuración utilizados en todo el sistema.
/boot/ Donde se almacenan los archivos utilizados durante el arranque del sistema (núcleo y discos
RAM).
/dev/ Dispositivos esenciales, discos duros, terminales, sonido, vídeo, lectores dvd/cd,
impresoras, ...
El resto de directorios son importantes y si se siente curiosidad es bueno buscar que contienen y
para que se usan. De todos modos con los descritos es suficiente para ir moviéndonos por la línea de
comandos y entender un poco como funciona el sistema.

14.2 Crear un disco en la RAM

Esto se ha de crear como usuario root.

Vamos a usar el directorio /mnt/ para crear allí un directorio llamado discoram
# cd /mnt
# mkdir discoram
Ahora vamos a crear una partición en la memoria RAM del sistema.
Con htop podemos ver que en nuestro caso disponemos de 2048Mb
Vamos a crear uno de 512Mb.
# mount -t tmpfs -o size=512m tmpfs /mnt/discoram/
Con eso ya hemos montado un disco en la ram que es accesible en /mnt/discoram
Nos metemos con cd al discoram y luego creamos un archivo de 10 megas:
# dd if=/dev/zero of=/mnt/discoram/archivode10megas bs=1M count=10
Si hacemos un ls -l veremos que el archivo ya existe y ocupa 10 megas.
Podemos crear unos cuantos más:
dd if=/dev/zero of=/mnt/discoram/archivode10megas2 bs=1M count=10
dd if=/dev/zero of=/mnt/discoram/archivode10megas3 bs=1M count=10
dd if=/dev/zero of=/mnt/discoram/archivode10megas4 bs=1M count=10
Y con htop vemos que el tamaño de la ram usado esta subiendo.
Estamos escribiendo en nuestra memoria RAM. Todo lo que hagamos va a ir increíblemente
rápido en este directorio ya que no estamos trabajando en el disco duro. Hemos montado una unidad
en la memoria ram y cuando la maquina se apaga se pierde todo.
Esto es tremendamente útil para muchas cosas. Vamos a desmontar esta unidad.
# cd ..
# umount discoram
Al desmontarla si usamos htop veremos que ya no ocupa tanto espacio en RAM.
Perderemos todo el contenido en este caso.
 015. Alias y otros comandos de utilidad

15.1 Creando alias

15.2 Otros comandos de utilidad

15.1 Creando alias

No vamos a encontrar un manual de alias. Alias es uno de esos comandos que vienen con bash
integrados de modo que para ver información sobre alias podemos usar help alias en vez de man
alias.
Un Alias como su nombre indica, nos servirá para reemplazar una palabra o serie de palabras con
otra más corta y sencilla.
Un ejemplo sencillo de comando que usamos mucho es ls -la
$ ls -la
Podemos crear un alias para que en vez de tener que escribir ls -la solamente escribiendo la
obtengamos el mismo resultado.
$ alias la=”ls -la”
Si ahora ejecutamos la obtendremos el mismo resultado que ejecutando ls -la.
$ la
Para recordar esto simplemente hemos de tener en cuenta esta sintaxis:
alias palabracorta=”palabra larga”
Algunas personas que vienen del mundo de windows lo mismo están acostumbradas a usar cls en
vez de clear o lo mismo prefieren usar limpiar en vez de clear. Para ello pueden crear alias así:
$ alias cls=”clear”
$ alias limpiar=”clear”
De esta forma si escribimos limpiar o cls se limpiará la pantalla.
Es importante saber que una vez cerramos sesión los alias se borran.
Si deseamos que estos alias se guarden permanentemente hemos de guardarlos en un archivo.
Este archivo es .bashrc un archivo oculto que tendremos en el raíz de nuestro home.
Podemos editar por tanto ese fichero con nano para justo en la parte donde aparecen los alias
comentados (es decir con # delante) ir añadiendo estos.
De esa forma creamos alias permanentes en esta maquina.
15.2 Otros comandos de utilidad

Es imposible aprendernos todos los comandos pero seguramente si usamos la línea de comandos
mucho iremos aprendiendo los más usuales para nuestras necesidades.
Si estos son largos podemos usar alias y personalizarlos a nuestro gusto.
Hemos de comentar una serie de comandos más que son de tremenda utilidad cuando nos
manejamos en la línea de comandos.
Estos son los siguientes:
grep
Nos permite filtrar contenido. Ejemplo:
$ cat archivo.txt | grep “hola”
o podemos usarlo sin utilizar cat y entubar así:
$ grep “adios” archivo.txt
Sacará solamente las lineas que coinciden. Nos sirve por tanto para buscar dentro de un archivo una
palabra o frase”.
lastlog
Nos permite ver los últimos accesos a la maquina.
$ lastlog
cut
Para cortar partes. Vamos a ver un ejemplo con la salida de lastlog
$ lastlog | cut -d “ “ -f 1
Indicamos que corte con el delimitador -d cuando vea “ “, es decir, un espacio. Indicamos con -f 1
que muestre la primera coincidencia. Nos mostrará solamente el nombre de usuario.
wc
Este ya lo hemos visto anteriormente. Nos servirá para contar. Contar lineas, contar palabras, …
$ lastlog | wc -l
Con eso contaremos lineas de la salida de lastlog.
Podemos usar grep y wc entubando para obtener una salida más filtrada.
$ lastlog | grep -v "**Never logged in**" | wc -l
uniq
Para reportar u omitir lineas repetidas.