103.2 Lección 1

Certificación:

LPIC-1

Versión:

5.0

Tema:

103 Comandos GNU y Unix

Objetivo:

103.2 Procesar secuencias de texto usando filtros

Lección:

1 de 1

Introducción

Tratar con el texto es una parte importante del trabajo de cada administrador de sistemas. Doug McIlroy, miembro del equipo de desarrollo original de Unix, resumió la filosofía de Unix y dijo (entre otras cosas importantes): “Escribir programas para manejar flujos de texto, porque esa es una interfaz universal”. Linux está inspirado en el funcionamiento de Unix y adopta firmemente su filosofía, por lo que un administrador debe esperar muchas herramientas de manipulación de texto dentro de una distribución de Linux.

Una revisión rápida sobre redirecciones y tuberías (Pipes)

También de la filosofía Unix:

Escriba programas que hagan una cosa y que la hagan bien.
Escribir programas para trabajar juntos.

Una forma importante de hacer que los programas funcionen juntos es a través de piping y redirections. Casi todos sus programas de manipulación de texto obtendrán texto de una entrada estándar (stdin), lo enviarán a una salida estándar (stdout) y enviarán eventuales errores a una salida de error estándar (stderr). A menos que especifique lo contrario, la entrada estándar será la que escriba en su teclado (el programa lo leerá después de presionar la tecla Enter). Del mismo modo, la salida estándar y los errores se mostrarán en la pantalla de su terminal. Veamos cómo funciona esto.

En su terminal, teclee cat y luego presione la tecla Enter. Luego teclee un texto al azar.

$ cat
This is a test
This is a test
Hey!
Hey!
It is repeating everything I type!
It is repeating everything I type!
(I will hit ctrl+c so I will stop this nonsense)
(I will hit ctrl+c so I will stop this nonsense)
^C

Para obtener más información sobre el comando cat (el término proviene de “concatenate”), consulte las páginas del manual.

Note	Si está trabajando en una instalación realmente simple de un servidor Linux, algunos comandos como `info` y `less` podrían no estar disponibles. Si este es el caso, instale estas herramientas utilizando el procedimiento adecuado en su sistema como se describe en las lecciones correspondientes.

Como se demostró anteriormente, si no especifica de dónde debe leer cat, leerá desde la entrada estándar (lo que escriba) y enviará lo que lea a su ventana de terminal (su salida estándar).

Ahora intente lo siguiente:

$ cat > mytextfile
This is a test
I hope cat is storing this to mytextfile as I redirected the output
I will hit ctrl+c now and check this
^C

$ cat mytextfile
This is a test
I hope cat is storing this to mytextfile as I redirected the output
I will hit ctrl+c now and check this

El > (mayor que) indica a cat que dirija su salida al archivo mytextfile, no a la salida estándar. Ahora intente esto:

$ cat mytextfile > mynewtextfile
$ cat mynewtextfile
This is a test
I hope cat is storing this to mytextfile as I redirected the output
I will hit ctrl+c now and check this

Esto tiene el efecto de copiar mytextfile a mynewtextfile. En realidad, puede verificar que estos dos archivos tengan el mismo contenido realizando un diff:

$ diff mynewtextfile mytextfile

Como no hay salida, los archivos son iguales. Ahora intente con el operador de redireccionamiento anexado (>>):

$ echo 'This is my new line' >> mynewtextfile
$ diff mynewtextfile mytextfile
4d3
< This is my new line

Hasta ahora hemos usado redirecciones para crear y manipular archivos. También podemos usar tuberías (representadas por el símbolo |) para redirigir la salida de un programa a otro. Encontremos las líneas donde se encuentra la palabra “this”:

$ cat mytextfile | grep this
I hope cat is storing this to mytextfile as I redirected the output
I will hit ctrl+c now and check this

$ cat mytextfile | grep -i this
This is a test
I hope cat is storing this to mytextfile as I redirected the output
I will hit ctrl+c now and check this

Ahora hemos canalizado la salida de cat a otro comando: grep. Note que cuando ignoramos mayúsculas y minúsculas (usando la opción -i) obtenemos una línea extra como resultado.

Procesando flujos de texto

Leer un archivo comprimido

Crearemos un archivo llamado ftu.txt que contenga una lista de los siguientes comandos:

bzcat
cat
cut
head
less
md5sum
nl
od
paste
sed
sha256sum
sha512sum
sort
split
tail
tr
uniq
wc
xzcat
zcat

Ahora usaremos el comando grep para imprimir todas las líneas que contienen la cadena cat:

$ cat ftu.txt | grep cat
bzcat
cat
xzcat
zcat

Otra forma de obtener esta información es simplemente usar el comando grep para filtrar el texto directamente, sin la necesidad de usar otra aplicación para enviar el flujo de texto a stdout.

$ grep cat ftu.txt
bzcat
cat
xzcat
zcat

Note	Recuerde que hay muchas formas de realizar la misma tarea con Linux.

Hay otros comandos que manejan archivos comprimidos (bzcat para archivos comprimidos bzip, xzcat para archivos comprimidos xz y zcat para archivos comprimidos gzip) y cada uno se usa para ver el contenido de un archivo comprimido basado en el algoritmo de compresión utilizado.

Verifique que el archivo recién creado ftu.txt sea el único en el directorio, luego cree una versión comprimida gzip del archivo:

$ ls ftu*
ftu.txt

$ gzip ftu.txt
$ ls ftu*
ftu.txt.gz

Luego, use el comando zcat para ver el contenido del archivo comprimido con gzip:

$ zcat ftu.txt.gz
bzcat
cat
cut
head
less
md5sum
nl
od
paste
sed
sha256sum
sha512sum
sort
split
tail
tr
uniq
wc
xzcat
zcat

Tenga en cuenta que gzip comprimirá ftu.txt en ftu.txt.gz y eliminará el archivo original. Por defecto, no se mostrará ningún resultado del comando gzip. Sin embargo, si desea que gzip le diga qué está haciendo, use la opción -v para la salida “verbose”.

Ver un archivo paginado

Usted sabe que cat concatena un archivo a la salida estándar (una vez que se proporciona un archivo después del comando). El archivo /var/log/syslog es donde su sistema Linux almacena todo lo importante que sucede en su sistema. Usando el comando sudo para elevar los privilegios para poder leer el archivo /var/log/syslog:

$ sudo cat /var/log/syslog

…verá mensajes que se desplazan muy rápido dentro de la ventana de su terminal. Puede canalizar la salida al programa less para que los resultados se paginen. Al usar less puede usar las teclas de flecha para navegar a través de la salida y también usar comandos similares a vi para navegar y buscar en todo el texto.

Sin embargo, en lugar de canalizar el comando cat en un programa de paginación, es más pragmático usar el programa de paginación directamente:

$ sudo less /var/log/syslog
... (salida omitida para mayor claridad)

Obtener una parte de un archivo de texto

Si solo es necesario revisar el inicio o el final de un archivo, hay otros métodos disponibles. El comando head se usa para leer las primeras diez líneas de un archivo de manera predeterminada, y el comando tail se usa para leer las últimas diez líneas de un archivo de manera predeterminada. Ahora intente:

$ sudo head /var/log/syslog
Nov 12 08:04:30 hypatia rsyslogd: [origin software="rsyslogd" swVersion="8.1910.0" x-pid="811" x-info="https://www.rsyslog.com"] rsyslogd was HUPed
Nov 12 08:04:30 hypatia systemd[1]: logrotate.service: Succeeded.
Nov 12 08:04:30 hypatia systemd[1]: Started Rotate log files.
Nov 12 08:04:30 hypatia vdr: [928] video directory scanner thread started (pid=882, tid=928, prio=low)
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'A - ATSC'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'C - DVB-C'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'S - DVB-S'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'T - DVB-T'
Nov 12 08:04:30 hypatia vdr[882]: vdr: no primary device found - using first device!
Nov 12 08:04:30 hypatia vdr: [929] epg data reader thread started (pid=882, tid=929, prio=high)
$ sudo tail /var/log/syslog
Nov 13 10:24:45 hypatia kernel: [ 8001.679238] mce: CPU7: Core temperature/speed normal
Nov 13 10:24:46 hypatia dbus-daemon[2023]: [session uid=1000 pid=2023] Activating via systemd: service name='org.freedesktop.Tracker1.Miner.Extract' unit='tracker-extract.service' requested by ':1.73' (uid=1000 pid=2425 comm="/usr/lib/tracker/tracker-miner-fs ")
Nov 13 10:24:46 hypatia systemd[2004]: Starting Tracker metadata extractor...
Nov 13 10:24:47 hypatia dbus-daemon[2023]: [session uid=1000 pid=2023] Successfully activated service 'org.freedesktop.Tracker1.Miner.Extract'
Nov 13 10:24:47 hypatia systemd[2004]: Started Tracker metadata extractor.
Nov 13 10:24:54 hypatia kernel: [ 8010.462227] mce: CPU0: Core temperature above threshold, cpu clock throttled (total events = 502907)
Nov 13 10:24:54 hypatia kernel: [ 8010.462228] mce: CPU4: Core temperature above threshold, cpu clock throttled (total events = 502911)
Nov 13 10:24:54 hypatia kernel: [ 8010.469221] mce: CPU0: Core temperature/speed normal
Nov 13 10:24:54 hypatia kernel: [ 8010.469222] mce: CPU4: Core temperature/speed normal
Nov 13 10:25:03 hypatia systemd[2004]: tracker-extract.service: Succeeded.

Para ayudar a ilustrar el número de líneas que se muestran, podemos canalizar la salida del comando head al comando nl, que mostrará el número de líneas de texto transmitidas al comando:

$ sudo head /var/log/syslog | nl
1	Nov 12 08:04:30 hypatia rsyslogd: [origin software="rsyslogd" swVersion="8.1910.0" x-pid="811" x-info="https://www.rsyslog.com"] rsyslogd was HUPed
2	Nov 12 08:04:30 hypatia systemd[1]: logrotate.service: Succeeded.
3	Nov 12 08:04:30 hypatia systemd[1]: Started Rotate log files.
4	Nov 12 08:04:30 hypatia vdr: [928] video directory scanner thread started (pid=882, tid=928, prio=low)
5	Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'A - ATSC'
6	Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'C - DVB-C'
7	Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'S - DVB-S'
8	Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'T - DVB-T'
9	Nov 12 08:04:30 hypatia vdr[882]: vdr: no primary device found - using first device!
10	Nov 12 08:04:30 hypatia vdr: [929] epg data reader thread started (pid=882, tid=929, prio=high)

Y podemos hacer lo mismo canalizando la salida del comando tail al comando wc, que por defecto contará el número de palabras dentro de un documento, y usando la opción -l para imprimir el número de líneas de texto que el comando ha leído:

$ sudo tail /var/log/syslog | wc -l
10

Si un administrador necesita revisar más (o menos) del comienzo o el final de un archivo, la opción -n puede usarse para limitar la salida del comando:

$ sudo tail -n 5 /var/log/syslog
Nov 13 10:37:24 hypatia systemd[2004]: tracker-extract.service: Succeeded.
Nov 13 10:37:42 hypatia dbus-daemon[2023]: [session uid=1000 pid=2023] Activating via systemd: service name='org.freedesktop.Tracker1.Miner.Extract' unit='tracker-extract.service' requested by ':1.73' (uid=1000 pid=2425 comm="/usr/lib/tracker/tracker-miner-fs ")
Nov 13 10:37:42 hypatia systemd[2004]: Starting Tracker metadata extractor...
Nov 13 10:37:43 hypatia dbus-daemon[2023]: [session uid=1000 pid=2023] Successfully activated service 'org.freedesktop.Tracker1.Miner.Extract'
Nov 13 10:37:43 hypatia systemd[2004]: Started Tracker metadata extractor.
$ sudo head -n 12 /var/log/syslog
Nov 12 08:04:30 hypatia rsyslogd: [origin software="rsyslogd" swVersion="8.1910.0" x-pid="811" x-info="https://www.rsyslog.com"] rsyslogd was HUPed
Nov 12 08:04:30 hypatia systemd[1]: logrotate.service: Succeeded.
Nov 12 08:04:30 hypatia systemd[1]: Started Rotate log files.
Nov 12 08:04:30 hypatia vdr: [928] video directory scanner thread started (pid=882, tid=928, prio=low)
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'A - ATSC'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'C - DVB-C'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'S - DVB-S'
Nov 12 08:04:30 hypatia vdr: [882] registered source parameters for 'T - DVB-T'
Nov 12 08:04:30 hypatia vdr[882]: vdr: no primary device found - using first device!
Nov 12 08:04:30 hypatia vdr: [929] epg data reader thread started (pid=882, tid=929, prio=high)
Nov 12 08:04:30 hypatia vdr: [882] no DVB device found
Nov 12 08:04:30 hypatia vdr: [882] initializing plugin: vnsiserver (1.8.0): VDR-Network-Streaming-Interface (VNSI) Server

Los fundamentos de sed, el Editor de Stream

Echemos un vistazo a los otros archivos, términos y utilidades que no tienen cat en sus nombres. Podemos hacer esto pasando la opción -v a grep, que indica al comando que solo muestre las líneas que no contienen cat:

$ zcat ftu.txt.gz | grep -v cat
cut
head
less
md5sum
nl
od
paste
sed
sha256sum
sha512sum
sort
split
tail
tr
uniq
wc

La mayor parte de lo que podemos hacer con grep también podemos hacerlo con sed, el editor de flujo para filtrar y transformar texto (como se indica en la página del manual sed). Primero recuperaremos nuestro archivo ftu.txt descomprimiendo nuestro archivo gzip del archivo:

$ gunzip ftu.txt.gz
$ ls ftu*
ftu.txt

Ahora, podemos usar sed para listar solo las líneas que contienen la cadena cat:

$ sed -n /cat/p < ftu.txt
bzcat
cat
xzcat
zcat

Hemos utilizado el signo menor que < para dirigir el contenido del archivo ftu.txt a al comando sed. La palabra encerrada entre barras (es decir, /cat/) es el término que estamos buscando. La opción -n instruye a sed para que no produzca salida (a menos por las instrucciones posteriores del comando p). Intente ejecutar este mismo comando sin la opción -n para ver qué sucede. Entonces intente esto:

$ sed /cat/d < ftu.txt
cut
head
less
md5sum
nl
od
paste
sed
sha256sum
sha512sum
sort
split
tail
tr
uniq
wc

Si no usamos la opción -n, sed imprimirá todo desde el archivo, excepto lo que la d indica a sed que elimine de su salida.

Un uso común de sed es buscar y reemplazar texto dentro de un archivo. Suponga que desea cambiar cada aparición de cat a dog. Puede usar sed para hacer esto proporcionando la opción s para intercambiar cada instancia del primer término, cat, por el segundo término, dog:

$ sed s/cat/dog/ < ftu.txt
bzdog
dog
cut
head
less
md5sum
nl
od
paste
sed
sha256sum
sha512sum
sort
split
tail
tr
uniq
wc
xzdog
zdog

En lugar de utilizar un operador de redireccionamiento (<) para pasar el archivo ftu.txt a nuestro comando sed, podemos hacer que el comando sed opere directamente en el archivo. Lo intentaremos a continuación, mientras creamos simultáneamente una copia de seguridad del archivo original:

$ sed -i.backup s/cat/dog/ ftu.txt
$ ls ftu*
ftu.txt  ftu.txt.backup

La opción -i realizará una operación sed directamente en el archivo original. Si no utiliza el .backup después del parámetro -i, simplemente sobreescribirá su archivo original. Cualquier cosa que use como texto después del parámetro -i será el nombre con el que se guardará el archivo original antes de las modificaciones que le solicitó a sed.

Garantizar la integridad de los datos

Hemos demostrado lo fácil que es manipular archivos en Linux. Hay momentos en los que es posible que desee compartir un archivo con otra persona, y desea asegurarse de que el destinatario termine con una copia verdadera del archivo original. Un uso muy común de esta técnica se practica cuando los servidores de distribución de Linux alojan imágenes de CD o DVD descargables de su software junto con archivos que contienen los valores de suma de comprobación calculados de esas imágenes de disco. Aquí hay un listado de ejemplo de un espejo de descarga de Debian:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[PARENTDIR] Parent Directory                                      -
[SUM]       MD5SUMS                              2019-09-08 17:46 274
[CRT]       MD5SUMS.sign                         2019-09-08 17:52 833
[SUM]       SHA1SUMS                             2019-09-08 17:46 306
[CRT]       SHA1SUMS.sign                        2019-09-08 17:52 833
[SUM]       SHA256SUMS                           2019-09-08 17:46 402
[CRT]       SHA256SUMS.sign                      2019-09-08 17:52 833
[SUM]       SHA512SUMS                           2019-09-08 17:46 658
[CRT]       SHA512SUMS.sign                      2019-09-08 17:52 833
[ISO]       debian-10.1.0-amd64-netinst.iso      2019-09-08 04:37 335M
[ISO]       debian-10.1.0-amd64-xfce-CD-1.iso    2019-09-08 04:38 641M
[ISO]       debian-edu-10.1.0-amd64-netinst.iso  2019-09-08 04:38 405M
[ISO]       debian-mac-10.1.0-amd64-netinst.iso  2019-09-08 04:38 334M
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

En la lista anterior, los archivos de imagen del instalador de Debian están acompañados por archivos de texto que contienen sumas de verificación de los archivos de los diversos algoritmos (MD5, SHA1, SHA256 y SHA512).

Note

Una suma de comprobación es un valor derivado de un cálculo matemático, basado en una función hash criptográfica, contra un archivo. Existen diferentes tipos de funciones hash criptográficas que varían en intensidad. El examen esperará que esté familiarizado con el uso de md5sum, sha256sum y sha512sum.

Una vez que descargue un archivo (por ejemplo, la imagen debian-10.1.0-amd64-netinst.iso), comparará la suma de comprobación del archivo que se descargó con un valor de suma de comprobación que se le proporcionó.

Aquí hay un ejemplo para ilustrar el punto. Calcularemos el valor SHA256 del archivo ftu.txt utilizando el comando sha256sum:

$ sha256sum ftu.txt
345452304fc26999a715652543c352e5fc7ee0c1b9deac6f57542ec91daf261c  ftu.txt

La larga cadena de caracteres que precede al nombre del archivo es el valor de suma de comprobación SHA256 de este archivo de texto. Cree un archivo que contenga ese valor, para usarlo durante la verificación de la integridad de nuestro archivo de texto original. Podemos hacer esto con el mismo comando sha256sum y redirigir la salida a un archivo:

$ sha256sum ftu.txt > sha256.txt

Ahora, para verificar el archivo ftu.txt, solo usamos el mismo comando y proporcionamos el nombre de archivo que contiene nuestro valor de suma de comprobación junto con -c:

$ sha256sum -c sha256.txt
ftu.txt: OK

El valor contenido en el archivo coincide con la suma de comprobación SHA256 calculada para nuestro archivo ftu.txt, tal como se espera. Sin embargo, si se modificara el archivo original (como algunos bytes perdidos durante la descarga de un archivo, o alguien lo hubiera alterado deliberadamente), la comprobación del valor fallará. En tales casos, sabemos que nuestro archivo está dañado o corrupto y no podemos confiar en la integridad de su contenido. Para probar el punto, agregaremos texto al final del archivo:

$ echo "new entry" >> ftu.txt

Ahora intentaremos verificar la integridad del archivo:

$ sha256sum -c sha256.txt
ftu.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Y vemos que la suma de comprobación no coincide con lo que se esperaba para el archivo. Por lo tanto, no podemos confiar en la integridad de este archivo. Podríamos intentar descargar una nueva copia de un archivo, informar el fallo de la suma de verificación al remitente del archivo o informarlo al equipo de seguridad del centro de datos, según la importancia del archivo.

Buscando más en los archivos

El comando octal dump (od) a menudo se usa para depurar aplicaciones y varios archivos. Por sí solo, el comando od solo enumerará el contenido de un archivo en formato octal. Podemos usar nuestro archivo ftu.txt de antes para practicar con este comando:

$ od ftu.txt
0000000 075142 060543 005164 060543 005164 072543 005164 062550
0000020 062141 066012 071545 005163 062155 071465 066565 067012
0000040 005154 062157 070012 071541 062564 071412 062145 071412
0000060 060550 032462 071466 066565 071412 060550 030465 071462
0000100 066565 071412 071157 005164 070163 064554 005164 060564
0000120 066151 072012 005162 067165 070551 073412 005143 075170
0000140 060543 005164 061572 072141 000012
0000151

La primera columna de salida es el desplazamiento de bytes para cada línea de salida. Como od imprime la información en formato octal de manera predeterminada, cada línea comienza con el desplazamiento de bytes de ocho bits, seguido de ocho columnas, cada una con el valor octal de los datos dentro de esa columna.

Tip	Recuerde que un byte tiene 8 bits de longitud.

Si necesita ver el contenido de un archivo en formato hexadecimal, use la opción -x:

$ od -x ftu.txt
0000000 7a62 6163 0a74 6163 0a74 7563 0a74 6568
0000020 6461 6c0a 7365 0a73 646d 7335 6d75 6e0a
0000040 0a6c 646f 700a 7361 6574 730a 6465 730a
0000060 6168 3532 7336 6d75 730a 6168 3135 7332
0000100 6d75 730a 726f 0a74 7073 696c 0a74 6174
0000120 6c69 740a 0a72 6e75 7169 770a 0a63 7a78
0000140 6163 0a74 637a 7461 000a
0000151

Ahora cada una de las ocho columnas después del desplazamiento de bytes está representada por sus equivalentes hexadecimales.

Un uso útil del comando od es para depurar scripts. Por ejemplo, el comando od puede mostrarnos caracteres que normalmente no se ven que existen dentro de un archivo, como las entradas newline. Podemos hacer esto con la opción -c, de modo que en lugar de mostrar la notación numérica para cada byte, estas entradas de columna se mostrarán como sus equivalentes de caracteres:

$ od -c ftu.txt
0000000   b   z   c   a   t  \n   c   a   t  \n   c   u   t  \n   h   e
0000020   a   d  \n   l   e   s   s  \n   m   d   5   s   u   m  \n   n
0000040   l  \n   o   d  \n   p   a   s   t   e  \n   s   e   d  \n   s
0000060   h   a   2   5   6   s   u   m  \n   s   h   a   5   1   2   s
0000100   u   m  \n   s   o   r   t  \n   s   p   l   i   t  \n   t   a
0000120   i   l  \n   t   r  \n   u   n   i   q  \n   w   c  \n   x   z
0000140   c   a   t  \n   z   c   a   t  \n
0000151

Todas las entradas de nueva línea dentro del archivo están representadas por los caracteres ocultos \n. Si solo desea ver todos los caracteres dentro de un archivo y no necesita ver la información de desplazamiento de bytes, la columna de desplazamiento de bytes se puede eliminar de la salida de la siguiente manera:

$ od -An -c ftu.txt
   b   z   c   a   t  \n   c   a   t  \n   c   u   t  \n   h   e
   a   d  \n   l   e   s   s  \n   m   d   5   s   u   m  \n   n
   l  \n   o   d  \n   p   a   s   t   e  \n   s   e   d  \n   s
   h   a   2   5   6   s   u   m  \n   s   h   a   5   1   2   s
   u   m  \n   s   o   r   t  \n   s   p   l   i   t  \n   t   a
   i   l  \n   t   r  \n   u   n   i   q  \n   w   c  \n   x   z
   c   a   t  \n   z   c   a   t  \n

Ejercicios Guiados

Alguien acaba de donar una computadora portátil a su escuela y ahora desea instalar Linux en ella. No hay manual y se vio obligado a arrancarlo desde una unidad de memoria USB sin gráficos en absoluto. Obtiene acceso a un terminal de shell y se conoce, para cada procesador que tenga, habrá una línea para él en el archivo /proc/cpuinfo:
```
processor	: 0
vendor_id	: GenuineIntel
cpu family	: 6
model		: 158

(líneas saltadas)

processor	: 1
vendor_id	: GenuineIntel
cpu family	: 6
model		: 158

(se saltaron más líneas)
```
- Usando los comandos grep y wc muestre cuántos procesadores tiene.
- Haga lo mismo con sed en lugar de grep.
Explore su archivo local /etc/passwd con los comandos grep, sed, head y tail según las siguientes tareas:
- ¿Qué usuarios tienen acceso a un shell Bash?
- Su sistema tiene varios usuarios que existen para manejar programas específicos o para fines administrativos. No tienen acceso a un shell. ¿Cuántos de esos existen en su sistema?
- ¿Cuántos usuarios y grupos existen en su sistema (recuerde: use solo el archivo /etc/passwd)?
- Muestre solo la primera línea, la última línea y la décima línea de su archivo /etc/passwd.

Considere este ejemplo de archivo /etc/passwd. Copie las líneas siguientes en un archivo local llamado mypasswd para este ejercicio.

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
nvidia-persistenced:x:121:128:NVIDIA Persistence Daemon,,,:/nonexistent:/sbin/nologin
libvirt-qemu:x:64055:130:Libvirt Qemu,,,:/var/lib/libvirt:/usr/sbin/nologin
libvirt-dnsmasq:x:122:133:Libvirt Dnsmasq,,,:/var/lib/libvirt/dnsmasq:/usr/sbin/nologin
carol:x:1000:2000:Carol Smith,Finance,,,Main Office:/home/carol:/bin/bash
dave:x:1001:1000:Dave Edwards,Finance,,,Main Office:/home/dave:/bin/ksh
emma:x:1002:1000:Emma Jones,Finance,,,Main Office:/home/emma:/bin/bash
frank:x:1003:1000:Frank Cassidy,Finance,,,Main Office:/home/frank:/bin/bash
grace:x:1004:1000:Grace Kearns,Engineering,,,Main Office:/home/grace:/bin/ksh
henry:x:1005:1000:Henry Adams,Sales,,,Main Office:/home/henry:/bin/bash
john:x:1006:1000:John Chapel,Sales,,,Main Office:/home/john:/bin/bash

Liste todos los usuarios en el grupo 1000 (use sed para seleccionar solo el campo apropiado) de su archivo mypasswd.
Liste solo los nombres completos de todos los usuarios de este grupo (use sed y cut).

Ejercicios Exploratorios

Una vez más, utilizando el archivo mypasswd de los ejercicios anteriores, idee un comando Bash que seleccionará a una persona de la Oficina Principal para ganar un concurso de rifas. Use el comando sed para imprimir solo las líneas de la Oficina Principal, y luego una secuencia de comando cut para recuperar el nombre de cada usuario de estas líneas. A continuación, deseará ordenar aleatoriamente estos nombres y solo imprimir el nombre superior de la lista.
¿Cuántas personas trabajan en Finanzas, Ingeniería y Ventas? (Considere explorar el comando uniq).
Ahora desea preparar un archivo CSV (valores separados por comas) para poder importar fácilmente, desde el archivo mypasswd del ejemplo anterior, el archivo names.csv a LibreOffice. El contenido del archivo tendrá el siguiente formato:
```
First Name,Last Name,Position
Carol,Smith,Finance
...
John,Chapel,Sales
```
Consejo: Utilice los comandos sed, cut y paste para lograr los resultados deseados. Tenga en cuenta que la coma (,) será el delimitador de este archivo.
Supongamos que la hoja de cálculo names.csv creada en el ejercicio anterior es un archivo importante y queremos asegurarnos de que nadie lo manipulará desde el momento en que se lo enviamos a alguien y el momento en que nuestro destinatario lo recibe. ¿Cómo podemos asegurar la integridad de este archivo usando md5sum?
Te prometiste a ti mismo que leerías un libro clásico de 100 líneas por día y decidiste comenzar con Mariner y Mystic de Herman Melville. Diseñe un comando usando split que separe este libro en secciones de 100 líneas cada una. Para obtener el libro en formato de texto plano, búsquelo en https://www.gutenberg.org.
Usando ls -l en el directorio /etc, ¿qué tipo de listado obtiene? Usando el comando cut en la salida del comando ls dado, ¿cómo mostraría solo los nombres de archivo? ¿Qué pasa con el nombre del archivo y el propietario de los archivos? Junto con los comandos ls -l y cut, utilice el comando tr para suprimir las apariciones múltiples de un espacio en un solo espacio para ayudar a formatear la salida con un comando cut.
Este ejercicio asume que está en una máquina real (no en una máquina virtual). También debe tener una memoria USB con usted. Revise las páginas del manual para el comando tail y descubra cómo seguir un archivo a medida que se le agrega texto. Mientras monitorea la salida de un comando tail en el archivo /var/log/syslog, inserte una memoria USB. Escriba el comando completo que usaría para obtener el Producto, el Fabricante y la cantidad total de almacenamiento de su memoria USB.

Resumen

Tratar con flujos de texto es de gran importancia cuando se administra cualquier sistema Linux. Las secuencias de texto se pueden procesar utilizando scripts para automatizar las tareas diarias o encontrar información de depuración relevante en los archivos de registro. Aquí hay un breve resumen de los comandos cubiertos en esta lección:

cat: Se usa para combinar o leer archivos de texto sin formato.
bzcat: Permite el procesamiento o lectura de archivos comprimidos utilizando el método bzip2.
xzcat: Permite el procesamiento o la lectura de archivos comprimidos utilizando el método xz.
zcat: Permite el procesamiento o la lectura de archivos comprimidos utilizando el método xz.
less: Este comando pagina los contenidos de un archivo, y permite la navegación y la funcionalidad de búsqueda.
head: Este comando mostrará las primeras 10 líneas de un archivo de forma predeterminada. Con el uso de la opción -n se pueden mostrar menos o más líneas.
tail: Este comando mostrará las últimas 10 líneas de un archivo de forma predeterminada. Con el uso de la opción -n se pueden mostrar menos o más líneas. La opción -f se utiliza para seguir la salida de un archivo de texto cuando se escriben nuevos datos.
wc: Abreviatura de “word count”, pero dependiendo de los parámetros que use contará caracteres, palabras y líneas.
sort: Se utiliza para organizar la salida de una lista alfabéticamente, alfabéticamente inversa o en orden aleatorio.
uniq: Se usa para enumerar (y contar) cadenas coincidentes.
od: El comando “octal dump” se utiliza para mostrar un archivo binario en notación octal, decimal o hexadecimal.
nl: El comando “number line” mostrará el número de líneas en un archivo, así como volver a crear un archivo con cada línea precedida por su número de línea.
sed: El editor de flujo se puede usar para encontrar ocurrencias coincidentes de cadenas usando Expresiones regulares, así como editar archivos usando patrones predefinidos.
tr: El comando traducir puede reemplazar caracteres y también elimina y comprime caracteres repetidos.
cut: Este comando puede imprimir columnas de archivos de texto como campos basados en el delimitador de caracteres de un archivo.
paste: Unir archivos en columnas según el uso de separadores de campo.
split: Este comando puede dividir archivos más grandes en archivos más pequeños según los criterios establecidos por las opciones del comando.
md5sum: Se utiliza para calcular el valor hash MD5 de un archivo. También se utiliza para verificar un archivo contra un valor hash existente para garantizar la integridad de un archivo.
sha256sum: Se utiliza para calcular el valor hash SHA256 de un archivo. También se utiliza para verificar un archivo contra un valor hash existente para garantizar la integridad de un archivo.
sha512sum: Se utiliza para calcular el valor hash SHA512 de un archivo. También se utiliza para verificar un archivo contra un valor hash existente para garantizar la integridad de un archivo.

Respuestas a los ejercicios guiados

Alguien acaba de donar una computadora portátil a su escuela y ahora desea instalar Linux en ella. No hay manual y se vio obligado a arrancarlo desde una unidad de memoria USB sin gráficos en absoluto. Obtiene acceso a un terminal de shell y se conoce, para cada procesador que tenga, habrá una línea para él en el archivo /proc/cpuinfo:
```
processor	: 0
vendor_id	: GenuineIntel
cpu family	: 6
model		: 158

(líneas saltadas)

processor	: 1
vendor_id	: GenuineIntel
cpu family	: 6
model		: 158

(se saltaron más líneas)
```
- Usando los comandos grep y wc muestra cuántos procesadores tiene.
  
  Aquí hay dos opciones:
  $ cat /proc/cpuinfo | grep processor | wc -l $ grep processor /proc/cpuinfo | wc -l
  Ahora que sabe que hay varias maneras en que puede hacer lo mismo, ¿cuándo debería usar una u otra? Realmente depende de varios factores, los dos más importantes son el rendimiento y la legibilidad. La mayoría de las veces usará comandos de shell dentro de scripts de shell para automatizar sus tareas y cuanto más grandes y complejos sean sus scripts, más tendrá que preocuparse por mantenerlos rápidos.
- Haga lo mismo con sed en lugar de grep
  
  Ahora, en lugar de grep intentaremos esto con sed:
  $ sed -n /processor/p /proc/cpuinfo | wc -l
  Aquí usamos sed con el parámetro -n para que sed no imprima nada excepto lo que coincide con la expresión processor, como lo indica el comando p. Como hicimos en las soluciones grep, wc -l contará la cantidad de líneas, por lo tanto, la cantidad de procesadores que tenemos.
  
  Estudie el siguiente ejemplo:
  $ sed -n /processor/p /proc/cpuinfo | sed -n '$='
  Esta secuencia de comandos proporciona resultados idénticos al ejemplo anterior donde la salida de sed se canalizaba a un comando wc. La diferencia aquí es que, en lugar de usar wc -l para contar el número de líneas, se invoca nuevamente sed para proporcionar una funcionalidad equivalente. Una vez más, estamos suprimiendo la salida de sed con la opción -n, excepto por la expresión que llamamos explícitamente, que es '$='. Esta expresión le dice a sed que coincida con la última línea ($) y luego imprima ese número de línea (=).
Explore su archivo local /etc/passwd con los comandos grep, sed, head y tail según las siguientes tareas:
- ¿Qué usuarios tienen acceso a un shell Bash?
  $ grep ":/bin/bash$" /etc/passwd
  Mejoraremos esta respuesta mostrando solo el nombre del usuario que utiliza el shell Bash.
  $ grep ":/bin/bash$" /etc/passwd | cut -d: -f1
  El nombre de usuario es el primer campo (parámetro -f1 del comando cut) y el archivo /etc/passwd usa : como separadores (parámetro -d: del comando cut) simplemente canalice la salida del comando grep al comando cut apropiado.
- Su sistema tiene varios usuarios que existen para manejar programas específicos o para fines administrativos. No tienen acceso a un shell. ¿Cuántos de esos existen en su sistema?
  
  La forma más fácil de encontrar esto es imprimiendo las líneas de las cuentas que no usan el shell Bash:
  $ grep -v ":/bin/bash$" /etc/passwd | wc -l
- ¿Cuántos usuarios y grupos existen en su sistema? (recuerde: use solo el archivo /etc/passwd)
  
  El primer campo de cualquier línea dada en su archivo /etc/passwd es el nombre de usuario, el segundo es típicamente una x que indica que la contraseña del usuario no está almacenada aquí (está encriptada en el archivo /etc/shadow ) El tercero es el ID de usuario (UID) y el cuarto es el ID de grupo (GID). Entonces esto debería darnos la cantidad de usuarios:
  $ cut -d: -f3 /etc/passwd | wc -l
  Bueno, la mayoría de las veces lo hará. Sin embargo, hay situaciones en las que establecerá diferentes superusuarios u otros tipos especiales de usuarios que comparten el mismo UID (ID de usuario). Entonces, para estar seguros, canalizaremos el resultado de nuestro comando cut al comando sort y luego contaremos el número de líneas.
  $ cut -d: -f3 /etc/passwd | sort -u | wc -l
  Ahora, para el número de grupos:
  $ cut -d: -f4 /etc/passwd | sort -u | wc -l
- Muestre solo la primera línea, la última línea y la décima línea de su archivo /etc/passwd
  
  Esto lo hará:
  $ sed -n -e '1'p -e '10'p -e '$'p /etc/passwd
  Recuerde que el parámetro -n le dice a sed que no imprima nada más que lo especificado por el comando p. El signo de dólar ($) usado aquí es una expresión regular que significa la última línea del archivo.

Considere este ejemplo de archivo /etc/passwd. Copie las líneas siguientes en un archivo local llamado mypasswd para este ejercicio.

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
nvidia-persistenced:x:121:128:NVIDIA Persistence Daemon,,,:/nonexistent:/sbin/nologin
libvirt-qemu:x:64055:130:Libvirt Qemu,,,:/var/lib/libvirt:/usr/sbin/nologin
libvirt-dnsmasq:x:122:133:Libvirt Dnsmasq,,,:/var/lib/libvirt/dnsmasq:/usr/sbin/nologin
carol:x:1000:2000:Carol Smith,Finance,,,Main Office:/home/carol:/bin/bash
dave:x:1001:1000:Dave Edwards,Finance,,,Main Office:/home/dave:/bin/ksh
emma:x:1002:1000:Emma Jones,Finance,,,Main Office:/home/emma:/bin/bash
frank:x:1003:1000:Frank Cassidy,Finance,,,Main Office:/home/frank:/bin/bash
grace:x:1004:1000:Grace Kearns,Engineering,,,Main Office:/home/grace:/bin/ksh
henry:x:1005:1000:Henry Adams,Sales,,,Main Office:/home/henry:/bin/bash
john:x:1006:1000:John Chapel,Sales,,,Main Office:/home/john:/bin/bash

Liste todos los usuarios en el grupo 1000 (use sed para seleccionar solo el campo apropiado) de su archivo mypasswd:

El GID es el cuarto campo en el archivo /etc/passwd. Puede tener la tentación de probar esto:
```
$ sed -n /1000/p mypasswd
```
En este caso, también obtendrá esta línea:
```
carol:x:1000:2000:Carol Smith,Finance,,,Main Office:/home/carol:/bin/bash
```
Esto no es correcto ya que Carol Smith es miembro de GID 2000 y la coincidencia se produjo debido al UID. Sin embargo, es posible que haya notado que después del GID, el siguiente campo comienza con un carácter en mayúscula. Podemos usar una expresión regular para resolver este problema.
```
$ sed -n /:1000:[A-Z]/p mypasswd
```
La expresión [A-Z] coincidirá con cualquier carácter en mayúsculas. Aprenderá más sobre esto en la lección respectiva.

Liste solo los nombres completos de todos los usuarios de este grupo (use sed y cut):

Utilice la misma técnica que utilizó para resolver la primera parte de este ejercicio y canalícela a un comando de corte.

$ sed -n /:1000:[A-Z]/p mypasswd | cut -d: -f5
Dave Edwards,Finance,,,Main Office
Emma Jones,Finance,,,Main Office
Frank Cassidy,Finance,,,Main Office
Grace Kearns,Engineering,,,Main Office
Henry Adams,Sales,,,Main Office
John Chapel,Sales,,,Main Office

¡No del todo! Tenga en cuenta cómo los campos dentro de sus resultados pueden estar separados por ,. Así que canalizaremos la salida a otro comando cut, usando , como delimitador.

$ sed -n /:1000:[A-Z]/p mypasswd | cut -d: -f5 | cut -d, -f1
Dave Edwards
Emma Jones
Frank Cassidy
Grace Kearns
Henry Adams
John Chapel

Respuestas a ejercicios exploratorios

Una vez más, utilizando el archivo mypasswd de los ejercicios anteriores, elabore un comando Bash que seleccione a una persona de la oficina principal para ganar un concurso de rifa. Utilice el comando sed para imprimir solo las líneas para la oficina principal, y luego una secuencia de comando cut para recuperar el nombre de cada usuario de estas líneas. A continuación, querrá ordenar estos nombres al azar e imprimir solo el nombre superior de la lista.

Primero explore cómo el parámetro -R manipula la salida del comando sort. Repita este comando un par de veces en su máquina (tenga en cuenta que deberá encerrar Main Office entre comillas simples, por lo que sed lo manejará como una sola cadena):
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d, -f1 | sort -R
```
Aquí hay una solución al problema:
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d, -f1 | sort -R | head -1
```
¿Cuántas personas trabajan en Finanzas, Ingeniería y Ventas? (Considere explorar el comando uniq).

Siga construyendo sobre la base de lo que aprendió en los ejercicios anteriores. Intente lo siguiente:
```
$ sed -n /'Main Office'/p mypasswd
$ sed -n /'Main Office'/p mypasswd | cut -d, -f2
```
Observe que ahora no nos importa el : como delimitador. Solo queremos el segundo campo cuando dividimos las líneas por los caracteres ,.
```
$ sed -n /'Main Office'/p mypasswd | cut -d, -f2 | uniq -c
      4 Finance
      1 Engineering
      2 Sales
```
El comando uniq solo generará las líneas únicas (no las líneas repetidas) y el parámetro -c le dice a uniq que cuente las ocurrencias de las líneas iguales. Aquí hay una advertencia: uniq solo considerará líneas adyacentes. Cuando este no sea el caso, tendrá que usar el comando sort.
Ahora desea preparar un archivo CSV (valores separados por comas) para que pueda importar fácilmente, desde el archivo mypasswd en el ejemplo anterior, el archivo names.csv a LibreOffice. El contenido del archivo tendrá el siguiente formato:
```
First Name,Last Name,Position
Carol,Smith,Finance
...
John,Chapel,Sales
```
Tip: Utilice los comandos sed, cut y paste para lograr los resultados deseados. Tenga en cuenta que la coma (,) será el delimitador de este archivo.

Comience con los comandos sed y cut, basándose en lo que aprendimos de los ejercicios anteriores:
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d" " -f1 > firstname
```
Ahora tenemos el archivo firstname con los nombres de nuestros empleados.
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d" " -f2 | cut -d, -f1 > lastname
```
Ahora tenemos el archivo lastname que contiene los apellidos de cada empleado.

A continuación, determinamos en qué departamento trabaja cada empleado:
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d, -f2 > department
```
Antes de trabajar en la solución final, pruebe los siguientes comandos para ver qué tipo de salida generan:
```
$ cat firstname lastname department
$ paste firstname lastname department
```
Y ahora para la solución final:
```
$ paste firstname lastname department | tr '\t' ,
$ paste firstname lastname department | tr '\t' , > names.csv
```
Aquí usamos el comando tr para traducir \t, el separador de tabulación, por un ,. tr es bastante útil cuando necesitamos intercambiar un carácter por otro. Asegúrese de revisar las páginas de manual para tr y paste. Por ejemplo, podemos usar la opción -d para el delimitador para hacer que el comando anterior sea menos complejo:
```
$ paste -d, firstname lastname department
```
Usamos el comando paste aquí una vez que necesitábamos familiarizarte con él. Sin embargo, podríamos haber realizado fácilmente todas las tareas en una sola cadena de comando:
```
$ sed -n /'Main Office'/p mypasswd | cut -d: -f5 | cut -d, -f1,2 | tr ' ' , > names.csv
```
Supongamos que la hoja de cálculo names.csv creada en el ejercicio anterior es un archivo importante y queremos asegurarnos de que nadie lo manipulará desde el momento en que se lo enviamos a alguien y el momento en que nuestro destinatario lo recibe. ¿Cómo podemos asegurar la integridad de este archivo usando md5sum?

Si busca en las páginas de manual md5sum, sha256sum y sha512sum, verá que todas comienzan con el siguiente texto:

“compute and check XXX message digest”

Donde “XXX” es el algoritmo que se utilizará para crear este resumen de mensajes.

Usaremos md5sum como ejemplo y luego puedes probar con los otros comandos.
```
$ md5sum names.csv
61f0251fcab61d9575b1d0cbf0195e25  names.csv
```
Ahora, por ejemplo, puede hacer que el archivo esté disponible a través de un servicio ftp seguro y enviar el mensaje resumen generado utilizando otro medio seguro de comunicación. Si el archivo ha sido ligeramente modificado, el mensaje resumen será completamente diferente. Solo para probarlo, edite names.csv y cambie Jones a James como se muestra aquí:
```
$ sed -i.backup s/Jones/James/ names.csv
$ md5sum names.csv
f44a0d68cb480466099021bf6d6d2e65  names.csv
```
Siempre que haga que los archivos estén disponibles para descargar, también es una buena práctica distribuir un message digest para que las personas que descarguen su archivo puedan producir un nuevo message digest y compararlo con el original. Si navega a través de https://kernel.org encontrará la página https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/sha256sums.asc donde puede obtener el sha256sum para todos los archivos disponible para descarga.
Te prometiste a ti mismo que leerías un libro clásico de 100 líneas por día y decidiste comenzar con Mariner y Mystic de Herman Melville. Diseñe un comando usando split que separe este libro en secciones de 100 líneas cada una. Para obtener el libro en formato de texto plano, búsquelo en https://www.gutenberg.org.

Primero obtendremos el libro completo del sitio del Proyecto Gutenberg, donde puede obtener este y otros libros que están disponibles en el dominio público.
```
$ wget https://www.gutenberg.org/files/50461/50461-0.txt
```
Es posible que necesite instalar wget si aún no está instalado en su sistema. Alternativamente, también puede usar curl. Use less para verificar el libro:
```
$ less 50461-0.txt
```
Ahora dividiremos el libro en trozos de 100 líneas cada uno:
```
$ split -l 100 -d 50461-0.txt melville
```
50461-0.txt es el archivo que dividiremos. melville será el prefijo para los archivos divididos. El -l 100 especifica el número de líneas y la opción -d le dice a split que numere los archivos (usando el sufijo proporcionado). Puede usar nl en cualquiera de los archivos divididos (probablemente no en el último) y confirmar que cada uno de ellos tenga 100 líneas.
Usando ls -l en el directorio /etc, ¿qué tipo de listado obtiene? Usando el comando cut en la salida del comando ls dado, ¿cómo mostraría solo los nombres de archivo? ¿Qué pasa con el nombre del archivo y el propietario de los archivos? Junto con los comandos ls -l y cut, utilice el comando tr para suprimir las apariciones múltiples de un espacio en un solo espacio para ayudar a formatear la salida con un comando cut.

El comando ls por sí solo le dará solo los nombres de los archivos. Sin embargo, podemos preparar la salida de ls -l (la lista larga) para extraer información más específica.
```
$ ls -l /etc | tr -s ' ' ,
drwxr-xr-x,3,root,root,4096,out,24,16:58,acpi
-rw-r--r--,1,root,root,3028,dez,17,2018,adduser.conf
-rw-r--r--,1,root,root,10,out,2,17:38,adjtime
drwxr-xr-x,2,root,root,12288,out,31,09:40,alternatives
-rw-r--r--,1,root,root,401,mai,29,2017,anacrontab
-rw-r--r--,1,root,root,433,out,1,2017,apg.conf
drwxr-xr-x,6,root,root,4096,dez,17,2018,apm
drwxr-xr-x,3,root,root,4096,out,24,16:58,apparmor
drwxr-xr-x,9,root,root,4096,nov,6,20:20,apparmor.d
```
El parámetro -s indica a tr que reduzca los espacios repetidos en una sola instancia de un espacio. El comando tr funciona para cualquier tipo de carácter repetitivo que especifique. Luego reemplazamos los espacios con una coma ,. En realidad, no necesitamos reemplazar los espacios en nuestro ejemplo, así que simplemente omitiremos el ,.
```
$ ls -l /etc | tr -s ' '
drwxr-xr-x 3 root root 4096 out 24 16:58 acpi
-rw-r--r-- 1 root root 3028 dez 17 2018 adduser.conf
-rw-r--r-- 1 root root 10 out 2 17:38 adjtime
drwxr-xr-x 2 root root 12288 out 31 09:40 alternatives
-rw-r--r-- 1 root root 401 mai 29 2017 anacrontab
-rw-r--r-- 1 root root 433 out 1 2017 apg.conf
drwxr-xr-x 6 root root 4096 dez 17 2018 apm
drwxr-xr-x 3 root root 4096 out 24 16:58 apparmor
```
Si solo se desean los nombres de archivo, todo lo que necesitamos que se muestre es el noveno campo:
```
$ ls -l /etc | tr -s ' ' | cut -d" " -f9
```
Para el nombre de archivo y el propietario de un archivo necesitaremos los campos noveno y tercero:
```
$ ls -l /etc | tr -s ' ' | cut -d" " -f9,3
```
¿Qué pasa si solo necesitamos los nombres de las carpetas y su propietario?
```
$ ls -l /etc | grep ^d | tr -s ' ' | cut -d" " -f9,3
```
Este ejercicio asume que está en una máquina real (no en una máquina virtual). También debe tener una memoria USB con usted. Revise las páginas del manual para el comando tail y descubra cómo seguir un archivo a medida que se le agrega texto. Mientras monitorea la salida de un comando tail en el archivo /var/log/syslog, inserte una memoria USB. Escriba el comando completo que usaría para obtener el Producto, el Fabricante y la cantidad total de almacenamiento de su memoria USB.
```
$ tail -f /var/log/syslog | grep -i 'product\:\|blocks\|manufacturer'
Nov  8 06:01:35 brod-avell kernel: [124954.369361] usb 1-4.3: Product: Cruzer Blade
Nov  8 06:01:35 brod-avell kernel: [124954.369364] usb 1-4.3: Manufacturer: SanDisk
Nov  8 06:01:37 brod-avell kernel: [124955.419267] sd 2:0:0:0: [sdc] 61056064 512-byte logical blocks: (31.3 GB/29.1 GiB)
```
Por supuesto, este es un ejemplo y los resultados pueden variar según el fabricante de la memoria USB. Observe que ahora usamos el parámetro -i con el comando grep ya que no estamos seguros de si las cadenas que estamos buscando estaban en mayúsculas o minúsculas. También utilizamos | como un OR lógico, por lo que buscamos líneas que contengan product OR blocks OR manufacturer.