User talk:Arlesy

Arlesy (talk) 09:59, August 12, 2017 (MDT) Inicio de traducción del curso Fundamentos de Linux, Parte 1

Antes de empezar

Acerca de este tutorial

Bienvenido a "Fundamentos de Linux," el primero de sus tutoriales hecho para prepararlo para el examen 101 de Linux Professional Institute's. En este tutorial, te presentamos a bash (el shell Linux estándar), te mostraremos cómo aprovechar al máximo los comandos estándar de Linux, como ls, cp y mv, explicar inodes, enlaces duros y simbólicos, y mucho más. Al final de este tutorial, tendrá una base sólida en los fundamentos de Linux e incluso estará listo para comenzar a aprender algunas tareas básicas de administración de sistemas Linux. Al final de esta serie de tutoriales (ocho en total), tendrá el conocimiento que necesita para convertirse en un Administrador de Sistemas Linux y estará listo para obtener una certificación LPIC Level 1 del Linux Professional Institute si así lo desea.

Este tutorial en particular (Parte 1) es ideal para aquellos que son nuevos en Linux, o aquellos que quieren revisar o mejorar su comprensión de conceptos fundamentales de Linux como copiar y mover archivos, creando vínculos simbólicos y vínculos duros, y usando comandos de procesamiento de texto estándar de Linux junto con tuberías y redirección. En el camino, vamos a compartir un montón de consejos y trucos para mantener el tutorial sustancioso y práctico, incluso para aquellos con una buena cantidad de experiencia previa de Linux. Para los principiantes, gran parte de este material será nuevo, pero los usuarios más experimentados de Linux pueden encontrar este tutorial como una gran forma de redondear sus habilidades fundamentales de Linux.

Para aquellos que han tomado la versión 1 de este tutorial por razones distintas a la preparación para el examen LPI, es probable que no necesite tomar esta.

Introducción a bash

El shell

Si has utilizado un sistema Linux, sabes que cuando inicias sesión, te recibe un mensaje que se parece a esto:

user $

El indicador particular que ve puede verse muy diferente. Puede contener el nombre de host del sistema, el nombre del directorio de trabajo actual o ambos. Pero independientemente de lo que su mensaje muestre, hay una cosa cierta. El programa que imprimió ese mensaje se denomina "shell", y es muy probable que su shell particular sea un programa llamado bash.

¿Está ejecutando bash?

Puede comprobar si está ejecutando bash escribiendo:

user $  echo $ SHELL 
/bin/bash

Si la línea anterior le dio un error o no respondió de manera similar a nuestro ejemplo, puede estar ejecutando un shell que no sea bash. En ese caso, la mayor parte de este tutorial todavía debe aplicarse, pero sería ventajoso que usted cambie a bash para una buena preparación del examen 101.

Acerca de bash

Bash, un acrónimo de "Bourne-again shell", es el shell por defecto en la mayoría de los sistemas Linux. El trabajo de la shell es obedecer sus comandos para que pueda interactuar con su sistema Linux. Cuando haya terminado de introducir los comandos, puede indicar al shell que salga o cierre la sesión, momento en el que se le devolverá a un indicador de inicio de sesión.

Por cierto, también puedes cerrar la sesión pulsando control-D en el prompt de bash.

Usando "cd"

Como usted probablemente ha encontrado, mirar la salida de bash no es la cosa más emocionante en el mundo. Por lo tanto, vamos a empezar a usar bash para navegar por nuestro sistema de archivos. En el indicador, escriba lo siguiente (sin el $):

user $ cd /

Acabamos de decirle a bash que quieres trabajar en /, también conocido como el directorio raíz; todos los directorios en el sistema forman un árbol, y / se considera la parte superior de este árbol, o la raíz. cd establece el directorio en el que está trabajando actualmente, también conocido como el "directorio de trabajo actual".

Paths(Rutas)

Para ver el directorio de trabajo actual de bash, puede escribir:

user $ pwd
user $ /

En el ejemplo anterior, el argumento / a cd se llama ruta. Le dice a cd dónde queremos ir. En particular, el argumento / es una ruta absoluta, lo que significa que especifica una ubicación relativa a la raíz del árbol del sistema de archivos. Rutas absolutas

Rutas absolutas

Aquí hay otras rutas absolutas:

/dev
/usr
/usr/bin
/usr/local/bin

Como puede ver, la única cosa que todos los rutas absolutas tienen en común es que comienzan con /. Con una ruta de acceso a /usr/local/bin, estamos diciendo a cd que entre en el directorio /, a continuación al directorio usr, luego local y bin. Las rutas absolutas se evalúan siempre comenzando en / primero.

Rutas relativas

El otro tipo de ruta se llama una ruta relativa. Bash, cd y otros comandos siempre interpretan estas rutas en relación con el directorio actual. Las rutas relativas nunca comienzan con un /. Por lo tanto, si estamos en /usr:

user $ cd /usr

Entonces, podemos usar una ruta relativa para cambiar al directorio /usr/local/bin:

user $ cd local/bin
user $ pwd
/usr/local/bin

Utilizando ..

Las rutas relativas también pueden contener uno o más directorios. El directorio .. es un directorio especial que apunta al directorio padre. Así, continuando desde el ejemplo anterior:

$ pwd
/usr/local/bin
$ cd ..
$ pwd
/usr/local

Como puede ver, nuestro directorio actual es ahora /usr/local. Pudimos retroceder

un directorio, relativo al directorio actual en el que estábamos.

Además, también podemos añadir .. a una ruta relativa existente, lo que nos permite entrar en un directorio que está junto a uno en el que ya estamos, por ejemplo:

$ pwd
/usr/local
$ cd ../share
$ pwd
/usr/share

Ejemplos de ruta relativa

Las rutas relativas pueden ser bastante complejas. Aquí hay algunos ejemplos, todos sin el directorio de destino resultante mostrado. Trate de averiguar dónde terminará después de escribir estos comandos:

$ cd /bin
$ cd ../usr/share/zoneinfo


$ cd /usr/X11R6/bin
$ cd ../lib/X11


$ cd /usr/bin
$ cd ../bin/../bin

Ahora, probarlos y ver si los tienes bien :)

Entendiendo el "."

Antes de terminar nuestra cobertura de cd, hay algunas cosas más que necesito mencionar. En primer lugar, hay otro directorio especial llamado., Que significa el directorio actual. Aunque este directorio no se utiliza con el comando cd, a menudo se utiliza para ejecutar algún programa en el directorio actual, de la siguiente manera:

$ ./myprog

En el ejemplo anterior, se ejecutará el ejecutable myprog residente en el directorio de trabajo actual.

cd y el directorio de inicio

Si queremos cambiar a nuestro directorio personal, podríamos escribir:

$ cd

Sin argumentos, cd cambiará a su directorio de inicio, que es /root para el superusuario y normalmente /home/nombre de usuario para un usuario normal. Pero ¿qué pasa si queremos especificar un archivo en nuestro directorio personal? Tal vez queramos pasar un argumento de archivo al comando myprog. Si el archivo reside en nuestro directorio personal, podemos escribir:

$ ./myprog /home/drobbins/myfile.txt

Sin embargo, usar un camino absoluto como ese no siempre es conveniente. Afortunadamente, podemos usar el carácter ~ (tilde) para hacer lo mismo:

$ ./myprog ~/myfile.txt

Directorios de inicio de otros usuarios

Bash expandirá un solo ~ para apuntar a su directorio personal, pero también puede usarlo para apuntar a los directorios de inicio de otros usuarios. Por ejemplo, si queremos hacer referencia a un archivo llamado fredsfile.txt en el directorio personal de Fred, podríamos escribir:

$ ./myprog ~fred/fredsfile.txt

Usando comandos de Linux

Introduciendo ls

Ahora, echaremos un vistazo al comando ls. Es muy probable que ya esté familiarizado con ls y sabe que al escribirlo por sí mismo se lista el contenido del directorio de trabajo actual:

$ cd /usr
$ ls
X11R6      doc         i686-pc-linux-gnu  lib      man          sbin   ssl
bin        gentoo-x86  include            libexec  portage      share  tmp
distfiles  i686-linux  info               local    portage.old  src

Al especificar la opción -a, puede ver todos los archivos de un directorio, incluidos los archivos ocultos: los que comienzan con (.). Como se puede ver en el ejemplo siguiente, ls -a revela los archivo . y .. directorio especial de enlaces:

$ ls -a
.      bin        gentoo-x86         include  libexec  portage      share  tmp
..     distfiles  i686-linux         info     local    portage.old  src
X11R6  doc        i686-pc-linux-gnu  lib      man      sbin         ssl

Listados largos del directorio

También puede especificar uno o más archivos o directorios en la línea de comandos de ls. Si especifica un archivo, ls mostrará ese archivo solamente. Si especifica un directorio, ls mostrará el contenido del directorio. La opción -l resulta muy útil cuando necesita ver los permisos, la propiedad, la hora de modificación y la información de tamaño en su lista de directorios.

En el ejemplo siguiente, usamos la opción -l para mostrar una lista completa de mi directorio /usr.

$ ls -l /usr
drwxr-xr-x    7 root     root          168 Nov 24 14:02 X11R6
drwxr-xr-x    2 root     root        14576 Dec 27 08:56 bin
drwxr-xr-x    2 root     root         8856 Dec 26 12:47 distfiles
lrwxrwxrwx    1 root     root            9 Dec 22 20:57 doc -> share/doc
drwxr-xr-x   62 root     root         1856 Dec 27 15:54 gentoo-x86
drwxr-xr-x    4 root     root          152 Dec 12 23:10 i686-linux
drwxr-xr-x    4 root     root           96 Nov 24 13:17 i686-pc-linux-gnu
drwxr-xr-x   54 root     root         5992 Dec 24 22:30 include
lrwxrwxrwx    1 root     root           10 Dec 22 20:57 info -> share/info
drwxr-xr-x   28 root     root        13552 Dec 26 00:31 lib
drwxr-xr-x    3 root     root           72 Nov 25 00:34 libexec
drwxr-xr-x    8 root     root          240 Dec 22 20:57 local
lrwxrwxrwx    1 root     root            9 Dec 22 20:57 man -> share/man
lrwxrwxrwx    1 root     root           11 Dec  8 07:59 portage -> gentoo-x86/
drwxr-xr-x   60 root     root         1864 Dec  8 07:55 portage.old
drwxr-xr-x    3 root     root         3096 Dec 22 20:57 sbin
drwxr-xr-x   46 root     root         1144 Dec 24 15:32 share
drwxr-xr-x    8 root     root          328 Dec 26 00:07 src
drwxr-xr-x    6 root     root          176 Nov 24 14:25 ssl
lrwxrwxrwx    1 root     root           10 Dec 22 20:57 tmp -> ../var/tmp

La primera columna muestra información de permisos para cada elemento del listado. Voy a explicar cómo interpretar esta información más adelante. La siguiente columna muestra el número de enlaces a cada objeto del sistema de archivos, que pasaremos por alto ahora, pero volveremos a ello más tarde. Las columnas tercera y cuarta listan el propietario y el grupo, respectivamente. La quinta columna muestra el tamaño del objeto. La sexta columna es el tiempo de última modificación o mtime del objeto. La última columna es el nombre del objeto. Si el archivo es un enlace simbólico, verá un apuntador -> y la ruta a la que apunta el enlace simbólico.

Mirando los directorios

A veces, usted querrá mirar un directorio, en lugar de dentro de él. Para estas situaciones, puede especificar la opción -d, que le dirá a ls que busque en cualquier directorio que normalmente buscaría en su interior:

$ ls -dl /usr /usr/bin /usr/X11R6/bin ../share
drwxr-xr-x    4 root     root           96 Dec 18 18:17 ../share
drwxr-xr-x   17 root     root          576 Dec 24 09:03 /usr
drwxr-xr-x    2 root     root         3192 Dec 26 12:52 /usr/X11R6/bin
drwxr-xr-x    2 root     root        14576 Dec 27 08:56 /usr/bin

Listados recursivos e inode

Así que puede usar -d para buscar en un directorio, pero también puede usar -R para hacer lo contrario: no sólo mirar dentro de un directorio, sino recursivamente buscar dentro de todos los archivos y directorios dentro de ese directorio! No incluiremos ningún ejemplo de salida para esta opción (ya que generalmente es voluminosa), pero es posible que desee probar algunos comandos ls -R y ls -Rl para obtener una idea de cómo funciona.

Finalmente, la opción ls -i se puede usar para mostrar los números de inodo de los objetos del sistema de archivos en el listado:

$ ls -i /usr
   1409 X11R6        314258 i686-linux           43090 libexec        13394 sbin
   1417 bin            1513 i686-pc-linux-gnu     5120 local          13408 share
   8316 distfiles      1517 include                776 man            23779 src
     43 doc            1386 info                 93892 portage        36737 ssl
  70744 gentoo-x86     1585 lib                   5132 portage.old      784 tmp

Comprensión de los inodos

A cada objeto de un sistema de archivos se le asigna un índice único, denominado número de inodo. Esto puede parecer trivial, pero entender los inodes es esencial para entender muchas operaciones del sistema de archivos. Por ejemplo, considere los enlaces . y .. que aparecen en cada directorio. Para entender completamente lo que realmente es un directorio, primero echaremos un vistazo al número de inodo de /usr/local:

$ ls -id /usr/local
   5120 /usr/local

El directorio /usr/local tiene un número de inodo de 5120. Ahora echemos un vistazo al número de inodo de /usr/local/bin/ ..:

$ ls -id /usr/local/bin/..
   5120 /usr/local/bin/..

Como puede ver, /usr/local/bin/ tiene el mismo número de inode que /usr/local! Así es como podemos enfrentarnos a esta sorprendente revelación. En el pasado, hemos considerado a / usr / local como el propio directorio. Ahora, descubrimos que el inode 5120 es de hecho el directorio, y hemos encontrado dos entradas de directorio (llamadas "enlaces") que apuntan a este inodo. Ambos /usr/local y /usr/local/bin/.. son enlaces a inode 5120. Aunque inode 5120 sólo existe en un lugar en el disco, varias cosas enlazan a él. Inode 5120 es la entrada real en el disco.

De hecho, podemos ver el número total de veces que el inodo 5120 se referenciado usando el comando

ls -dl

:

$ ls -dl /usr/local
drwxr-xr-x    8 root     root          240 Dec 22 20:57 /usr/local

Si echamos un vistazo a la segunda columna de la izquierda, vemos que el directorio / usr / local (inode 5120) se hace referencia ocho veces. En mi sistema, aquí están los varios caminos que hacen referencia a este inodo:

/usr/local
/usr/local/.
/usr/local/bin/..
/usr/local/games/..
/usr/local/lib/..
/usr/local/sbin/..
/usr/local/share/..
/usr/local/src/..

mkdir

Echemos un rápido vistazo al comando mkdir, que se puede utilizar para crear nuevos directorios. El siguiente ejemplo crea tres nuevos directorios, tic, tac y toe, todos bajo

$ cd /tmp
$ mkdir tic tac toe

De forma predeterminada, el comando mkdir no crea directorios principales para usted; toda la ruta desde el primer elemento hasta el último necesita existir. Por lo tanto, si desea crear los directorios ganados won/der/ful, necesitará emitir tres comandos mkdir independientes:

$ mkdir won/der/ful
mkdir: cannot create directory `won/der/ful': No such file or directory
$ mkdir won
$ mkdir won/der
$ mkdir won/der/ful

Sin embargo, mkdir tiene una opción práctica -p que le dice a mkdir que cree cualquier directorio padre faltante, como puede ver aquí:

$ mkdir -p easy/as/pie

En general, es bastante sencillo. Para obtener más información sobre el comando mkdir, escriba man mkdir para leer la página de manual. Esto funcionará para casi todos los comandos cubiertos aquí (por ejemplo, man ls), excepto para cd, que está incorporado en bash.

touch

Ahora, vamos a echar un vistazo rápido a los comandos cp y mv, utilizados para copiar, cambiar el nombre y mover archivos y directorios. Para comenzar esta descripción, primero usaremos el comando touch para crear un archivo en /tmp:

$ cd /tmp
$ touch copyme

El comando touch actualiza el mtime de un archivo si existe (recuerde la sexta columna en la salida ls -l). Si el archivo no existe, se creará un nuevo archivo vacío. Ahora debe tener un archivo /tmp/copyme con un tamaño de cero.

echo

Ahora que el archivo existe, vamos a agregar algunos datos al archivo. Podemos hacerlo usando el comando echo, que toma sus argumentos y los imprime a la salida estándar. En primer lugar, el comando de eco en sí mismo:

$ echo "firstfile"
firstfile

Ahora, el mismo comando de eco con redirección de salida:

$ echo "firstfile" > copyme

El signo mayor que indica al shell que escriba la salida de eco en un archivo llamado copyme. Este archivo se creará si no existe y se sobrescribirá si existe. Escribiendo ls -l, podemos ver que el archivo copyme tiene 10 bytes de largo, ya que contiene la palabra firstfile y el caracter newline:

ls -l, we can see that the copyme file is 10 bytes long, since it contains the word firstfile and the newline character:

$ ls -l copyme
-rw-r--r--    1 root     root           10 Dec 28 14:13 copyme

cat y cp

Para mostrar el contenido del archivo en el terminal, utilice el comando cat:

$ cat copyme
firstfile

Ahora, podemos usar una invocación básica del comando cp para crear un archivo copiedme copiado del archivo original:

$ cp copyme copiedme

Tras la investigación, encontramos que son archivos verdaderamente separados; sus números de inodo son diferentes:

$ ls -i copyme copiedme
  648284 copiedme   650704 copyme

mv

Ahora, vamos a usar el comando mv para cambiar el nombre de copiedme a movedme. El número de inodo permanecerá igual; sin embargo, el nombre de archivo que apunta al inodo cambiará.

$ mv copiedme movedme
$ ls -i movedme
  648284 movedme

El número de inodo de un archivo movido permanecerá igual mientras el archivo de destino resida en el mismo sistema de archivos que el archivo de origen. Echaremos un vistazo a los sistemas de archivos en Linux Fundamentals, Part 3 de esta serie de tutoriales.

Mientras hablamos de mv, veamos otra forma de usar este comando. mv, además de permitirnos cambiar el nombre de los archivos, también nos permite mover uno o más archivos a otra ubicación en la jerarquía de directorios. Por ejemplo, para mover /var/tmp/myfile.txt a /home/drobbins (que pasa a ser mi directorio personal), podría escribir:

$ mv /var/tmp/myfile.txt /home/drobbins

Después de escribir este comando, myfile.txt se moverá a /home/drobbins/myfile.txt. Y si /home/drobbins está en un sistema de archivos diferente de /var/tmp, el comando mv controlará la copia de myfile.txt al nuevo sistema de archivos y lo borrará del antiguo sistema de archivos. Como se puede adivinar, cuando myfile.txt se mueve entre sistemas de archivos, myfile.txt en la nueva ubicación tendrá un nuevo número de inodo. Esto se debe a que cada sistema de archivos tiene su propio conjunto independiente de números de inodo.

También podemos usar el comando mv para mover varios archivos a un único directorio de destino. Por ejemplo, para mover myfile1.txt y myarticle3.txt a /home/drobbins, podría escribir:

$ mv /var/tmp/myfile1.txt /var/tmp/myarticle3.txt /home/drobbins

Creando Enlaces y Removiendo Archivos

Enlaces duros

Hemos mencionado el término enlace cuando nos referimos a la relación entre las entradas de directorio (los nombres que escribimos) y los inodos (los números de índice en el sistema de archivos subyacente que normalmente podemos ignorar). En realidad hay dos tipos de enlaces disponibles en Linux. El tipo que hemos discutido hasta ahora se llama enlaces duros. Un inodo dado puede tener cualquier número de enlaces duros, y el inodo persistirá en el sistema de archivos hasta que todos los enlaces duros desaparezcan. Cuando el último vínculo duro desaparezca y ningún programa mantenga abierto el archivo, Linux eliminará el archivo automáticamente. Se pueden crear nuevos vínculos duros mediante el comando ln:

$ cd /tmp
$ touch firstlink
$ ln firstlink secondlink
$ ls -i firstlink secondlink
  15782 firstlink    15782 secondlink

Como puede ver, los enlaces duros funcionan en el nivel de inodo para apuntar a un archivo en particular. En sistemas Linux, los enlaces duros tienen varias limitaciones. Por un lado, sólo puede hacer enlaces duros a los archivos, no a los directorios. Está bien; aunque . y .. son enlaces duros a los directorios creados por el sistema, usted (incluso como el usuario root) no están autorizados a crearlos por cuenta propia. La segunda limitación de los enlaces duros es que no pueden abarcar los sistemas de archivos; que sería el caso si los sistemas de archivos se encuentran en particiones de disco independientes. Esto significa que no puede crear un enlace desde /usr/bin/bash a /bin/bash si sus directorios / y /usr existen en particiones de disco separadas.

Enlaces simbólicos

En la práctica, los enlaces simbólicos (o symlinks) se utilizan con más frecuencia que los enlaces duros. Los enlaces simbólicos son un tipo de archivo especial donde el vínculo se refiere a otro archivo por nombre, en lugar de directamente al inodo. Los enlaces simbólicos no impiden que se elimine un archivo; Si el archivo de destino desaparece, entonces el enlace simbólico sólo será inutilizable o roto.

Se puede crear un enlace simbólico pasando la opción -s a ln.

$ ln -s secondlink thirdlink
$ ls -l firstlink secondlink thirdlink
-rw-rw-r--    2 agriffis agriffis        0 Dec 31 19:08 firstlink
-rw-rw-r--    2 agriffis agriffis        0 Dec 31 19:08 secondlink
lrwxrwxrwx    1 agriffis agriffis       10 Dec 31 19:39 thirdlink -> secondlink

Los enlaces simbólicos se pueden distinguir en ls -l salida de archivos normales de tres maneras. En primer lugar, observe que la primera columna contiene un carácter l para indicar el enlace simbólico. En segundo lugar, el tamaño del enlace simbólico es el número de caracteres en el destino (segundo enlace, en este caso). En tercer lugar, la última columna de la salida muestra el nombre de archivo de destino precedido por una flecha ->.

Symlinks en profundidad

Los enlaces simbólicos son generalmente más flexibles que los enlaces duros. Puede crear un vínculo simbólico con cualquier tipo de objeto del sistema de archivos, incluidos los directorios. Y debido a que la implementación de enlaces simbólicos se basa en rutas (no en inodos), está perfectamente bien crear un enlace simbólico que apunte a un objeto en otro sistema de archivos físico; es decir, una partición de disco diferente. Sin embargo, este hecho también puede hacer que los enlaces simbólicos sean difíciles de entender.

Considere una situación donde queremos crear un enlace en /tmp que apunte a /usr/local/bin. Deberíamos escribir esto:

$ ln -s /usr/local/bin bin1
$ ls -l bin1
lrwxrwxrwx    1 root     root           14 Jan  1 15:42 bin1 -> /usr/local/bin

O alternativamente:

$ ln -s ../usr/local/bin bin2
$ ls -l bin2
lrwxrwxrwx    1 root     root           16 Jan  1 15:43 bin2 -> ../usr/local/bin

Como puede ver, ambos enlaces simbólicos apuntan al mismo directorio. Sin embargo, si nuestro segundo enlace simbólico es movido a otro directorio, se "romperá" debido a la ruta relativa:

$ ls -l bin2
lrwxrwxrwx    1 root     root           16 Jan  1 15:43 bin2 -> ../usr/local/bin
$ mkdir mynewdir
$ mv bin2 mynewdir
$ cd mynewdir
$ cd bin2
bash: cd: bin2: No such file or directory

Debido a que el directorio /tmp/usr/local/bin no existe, ya no podemos cambiar los directorios en bin2; en otras palabras, bin2 está ahora roto.

Por esta razón, a veces es una buena idea evitar crear enlaces simbólicos con la información de ruta relativa. Sin embargo, hay muchos casos donde los enlaces simbólicos relativos son muy útiles. Considere un ejemplo en el que desea crear un nombre alternativo para un programa en /usr/bin:

# ls -l /usr/bin/keychain 
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/bin/keychain

Como usuario root, puede crear un nombre alternativo para keychain, como kc. En este ejemplo, tenemos acceso de root, como lo demuestra nuestro indicador bash cambiando a "#". Necesitamos acceso root porque los usuarios normales no pueden crear archivos en /usr/bin. Como root, podríamos crear un nombre alternativo para keychain de la siguiente manera:

# cd /usr/bin
# ln -s /usr/bin/keychain kc
# ls -l keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/bin/keychain
# ls -l kc       
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> /usr/bin/keychain

En este ejemplo, creamos un enlace simbólico llamado kc que apunta al archivo /usr/bin/keychain.

Si bien esta solución funcionará, creará problemas si decidimos que queremos mover ambos archivos, /usr/bin/keychain y /usr/bin/kc a /usr/local/bin:

# cd /usr/bin
# ln -s keychain kc
# ls -l kc
lrwxrwxrwx    1 root     root            8 Jan  5 12:40 kc -> keychain
# mv keychain kc /usr/local/bin
# ls -l /usr/local/bin/keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/local/bin/keychain
# ls -l /usr/local/bin/kc
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> keychain

Debido a que usamos un camino absoluto en nuestro enlace simbólico, nuestro enlace simbólico kc sigue apuntando a /usr/bin/ keychain, que ya no existe desde que movimos /usr/bin/keychain a /usr/local/bin.

Eso significa que kc es ahora un enlace simbólico roto. Tanto las rutas relativas como las absolutas en los enlaces simbólicos tienen sus méritos, y debe usar un tipo de ruta que sea apropiado para su aplicación particular. A menudo, un camino relativo o absoluto funcionará bien. El ejemplo siguiente habría funcionado incluso después de mover ambos archivos:

# cd /usr/bin
# ln -s keychain kc
# ls -l kc
lrwxrwxrwx    1 root     root            8 Jan  5 12:40 kc -> keychain
# mv keychain kc /usr/local/bin
# ls -l /usr/local/bin/keychain
-rwxr-xr-x    1 root     root        10150 Dec 12 20:09 /usr/local/bin/keychain
# ls -l /usr/local/bin/kc
lrwxrwxrwx    1 root     root           17 Mar 27 17:44 kc -> keychain

Ahora, podemos ejecutar el programa keychain escribiendo /usr/local/bin/kc. /usr/local/bin/kc apunta al llavero del programa en el mismo directorio que kc.

rm

Ahora que sabemos cómo usar cp, mv y ln, es hora de aprender a eliminar objetos del sistema de archivos. Normalmente, esto se hace con el comando rm. Para eliminar archivos, simplemente especifíquelos en la línea de comandos:

$ cd /tmp
$ touch file1 file2
$ ls -l file1 file2
-rw-r--r--    1 root     root            0 Jan  1 16:41 file1
-rw-r--r--    1 root     root            0 Jan  1 16:41 file2
$ rm file1 file2
$ ls -l file1 file2
ls: file1: No such file or directory
ls: file2: No such file or directory

Tenga en cuenta que bajo Linux, una vez que un archivo es removido, normalmente se va para siempre. Por esta razón, muchos administradores de sistema junior utilizarán la opción -i al eliminar archivos. La opción -i le dice a rm que elimine todos los archivos en modo interactivo, es decir, antes de quitar cualquier archivo. Por ejemplo:

$ rm -i file1 file2
rm: remove regular empty file `file1'? y
rm: remove regular empty file `file2'? y

En el ejemplo anterior, el comando rm indicó si los archivos especificados deberían *realmente* eliminarse. Para que se eliminaran, tuve que escribir "y" y presionar Enter dos veces. Si hubiera escrito n, el archivo no se habría eliminado. O, si hubiera hecho algo realmente mal, podría haber tecleado Control-C para abortar el comando rm -i enteramente - todo antes de poder hacer cualquier daño potencial a mi sistema. Si todavía se está acostumbrando al comando rm, puede ser útil agregar la siguiente línea al archivo ~ / .bashrc usando su editor de texto favorito y luego cerrar la sesión y volver a iniciarla. Entonces, cada vez que escriba rm, El shell de bash lo convertirá automáticamente en un comando rm -i. De esta manera, rm siempre funcionará en modo interactivo:

alias rm="rm -i"

rmdir

Para quitar directorios, tiene dos opciones. Puede quitar todos los objetos dentro del directorio y luego usar rmdir para quitar el propio directorio:

$ mkdir mydir
$ touch mydir/file1
$ rm mydir/file1
$ rmdir mydir

Este método se conoce comúnmente como eliminación de directorios para bobos. Todos los usuarios avanzados y administradores reales, #worth their salt utilizan el comando rm -rf mucho más conveniente, que se describe a continuación. La mejor manera de eliminar un directorio es utilizar las opciones de fuerza recursiva del comando rm para indicar a rm que elimine el directorio especificado, así como todos los objetos contenidos en el directorio:

$ rm -rf mydir

Generalmente, rm -rf es el método preferido para eliminar un árbol de directorios. Tenga mucho cuidado al usar rm -rf, ya que su poder puede ser usado tanto para el bien como para el mal :)

Uso de comodines

Presentación de comodines

En tu uso cotidiano de Linux, muchas veces necesitas realizar una sola operación (como rm) en muchos objetos del sistema de archivos a la vez. En estas situaciones, a menudo puede resultar engorroso escribir muchos archivos en la línea de comandos:

$ rm file1 file2 file3 file4 file5 file6 file7 file8

Para solucionar este problema, puede aprovechar el soporte de comodines incorporado de Linux. Este soporte, también llamado globbing (por razones históricas), le permite especificar múltiples archivos a la vez usando un patrón comodín. Bash y otros comandos de Linux interpretarán este patrón buscando en el disco y encontrando cualquier archivo que coincida con él. Por lo tanto, si tenía archivos de archivo1 a archivo8 en el directorio de trabajo actual, podría eliminar estos archivos escribiendo:

$ rm file[1-8]

O si simplemente quería eliminar todos los archivos cuyos nombres empiezan por archivo, así como cualquier archivo con nombre archivo, podría escribir:

$ rm file*

El comodín * coincide con cualquier carácter o secuencia de caracteres, o incluso sin carácter. Por supuesto, los comodines glob pueden usarse para algo más que simplemente eliminar archivos, como veremos en el siguiente panel.

Entendiendo las no coincidencias

Si desea listar todos los objetos del sistema de archivos en /etc que comienzan con g, así como cualquier archivo llamado g, podría escribir:

$ ls -d /etc/g*
/etc/gconf  /etc/ggi  /etc/gimp  /etc/gnome  /etc/gnome-vfs-mime-magic  /etc/gpm  /etc/group  /etc/group-

Ahora, ¿qué ocurre si especifica un patrón que no coincide con ningún objeto del sistema de archivos? En el ejemplo siguiente, intentamos listar todos los archivos en /usr/bin que comienzan con asdf y terminan con jkl, incluyendo potencialmente el archivo asdfjkl:

$ ls -d /usr/bin/asdf*jkl
ls: /usr/bin/asdf*jkl: No such file or directory

Esto es lo que pasó. Normalmente, cuando especificamos un patrón, ese patrón coincide con uno o más archivos en el sistema de archivos subyacente, y bash reemplaza el patrón con una lista separada por espacios de todos los objetos coincidentes . Sin embargo, cuando el patrón no produce ninguna coincidencia, bash deja el argumento, wild cards y todos, tal cual . Por lo tanto, entonces ls no puede encontrar el archivo / usr / bin / asdf * jkl y nos da un error. La regla operativa aquí es que los patrones glob se expanden sólo si coinciden con los objetos del sistema de archivos . De lo contrario, permanecen como están y se pasan literalmente al programa que está llamando.

Sintaxis de comodín: * y ?

Ahora que hemos visto cómo globbing funciona, debemos ver la sintaxis de comodines. Puede utilizar caracteres especiales para la expansión de comodines:

* coincidirá con cero o más caracteres. Significa "cualquier cosa puede ir aquí, incluyendo nada". Ejemplos:

• /etc/g * hace coincidir todos los archivos de /etc que comienzan con g, o un archivo llamado g.
• /tmp/my * 1 coincide con todos los archivos en /tmp que comienzan con mi y terminan con 1, incluido el archivo my1.

? coincide con cualquier carácter. Ejemplos:

• mi_archivo? Coincide con cualquier archivo cuyo nombre consta de mi_archivo seguido de un solo carácter
• /tmp/notes?txt coincidiría con /tmp/notes.txt y /tmp/notes_txt, si existen

Sintaxis de comodín: []

Este comodín es como un ?, Pero permite una mayor especificidad. Para utilizar esta tarjeta comodín, coloque los caracteres que desee coincidir dentro de []. La expresión resultante coincidirá con una sola ocurrencia de cualquiera de estos caracteres. También puede utilizar - para especificar un rango e incluso combinar rangos. Ejemplos:

• myfile[12] coincidirá myfile1 y myfile2. El comodín se expandirá siempre que al menos uno de estos archivos exista en el directorio actual.
• [Cc]hange[Ll]og coincidirá con Changelog, ChangeLog, changeLog y changelog. Como puede ver, el uso de comodines puede ser útil para hacer coincidir variaciones en mayúsculas.
• ls/etc/[0-9] * mostrará todos los archivos de / etc que comiencen con un número.
• ls/tmp/[A-Za-z] * mostrará todos los archivos en /tmp que comienzan con una letra mayúscula o minúscula.

El constructor [!] es similar al constructor [], excepto que en lugar de coincidir con cualquier carácter dentro de los corchetes, coincidirá con cualquier caracter, siempre y cuando no se encuentra entre la lista [! and]. Ejemplo:

• rm myfile [! 9] eliminará todos los archivos llamados myfile más un solo carácter, excepto myfile9

Advertencias de comodines

Aquí hay algunas advertencias a tener en cuenta cuando se usan comodines. Dado que bash trata los caracteres comodín (?, [,] y *) especialmente, debe tener especial cuidado al escribir un argumento en un comando que contenga estos caracteres. Por ejemplo, si desea crear un archivo que contenga la cadena [fo] *, el siguiente comando no puede hacer lo que desea:

$ echo [fo]* > /tmp/mynewfile.txt

Si el patrón [fo] * coincide con cualquier archivo del directorio de trabajo actual, encontrarás los nombres de esos archivos dentro de /tmp/mynewfile.txt en lugar de un literal [fo] * como esperabas. ¿La solución? Bueno, un enfoque es rodear a sus caracteres con comillas simples, que dicen a bash que no realizar absolutamente ninguna expansión de comodín en ellos:

$ echo '[fo]*' > /tmp/mynewfile.txt

Utilizando este enfoque, su nuevo archivo contendrá un literal [fo] * como se esperaba. Alternativamente, puede usar la barra invertida para decirle a bash que [,], y * deberían ser tratados literalmente en lugar de como comodines:

$ echo \[fo\]\* > /tmp/mynewfile.txt

Ambos enfoques (comillas simples y barra invertida) tienen el mismo efecto. Dado que estamos hablando de expansión de barra invertida, ahora sería un buen momento para mencionar que para especificar un literal \, también puede incluirlo entre comillas simples o tipo \\ (se expandirá a \) . Nota

   Note

Las comillas dobles funcionarán de forma similar a las comillas simples, pero todavía le permitirán a bash hacer alguna expansión limitada. Por lo tanto, las comillas simples son su mejor apuesta cuando realmente está interesado en pasar el texto literal a un comando. Para obtener más información sobre la expansión de comodines, escriba man 7 glob. Para más información sobre citar en bash, escriba man 8 glob y lea la sección titulada QUOTING. Si está planeando tomar los exámenes LPI, considere esto como una tarea :)

Resumen y recursos

Resumen

Felicitaciones; ¡Has llegado al final de nuestra revisión de los fundamentos de Linux! Espero que le haya ayudado a consolidar su conocimiento básico de Linux. Los temas que has aprendido aquí, incluyendo los conceptos básicos de bash, comandos básicos de Linux, enlaces y comodines, han sentado las bases para nuestro próximo tutorial sobre administración básica, en el que cubriremos temas como expresiones regulares, propiedad y permisos , Administración de cuentas de usuario y más.

Al continuar en esta serie de tutoriales, pronto estarás listo para obtener tu certificación LPIC Level 1 del Linux Professional Institute. Hablando de certificación LPIC, si esto es algo que le interesa, le recomendamos que estudie los recursos en el siguiente panel, que han sido cuidadosamente seleccionados para aumentar el material cubierto en este tutorial.