Nota del autor: Gran parte del contenido de este artículo está extraído del Capítulo 3:Flujos de datos, de mi nuevo libro, The Linux Philosophy for SysAdmins.
Todo en Linux gira en torno a flujos de datos, particularmente flujos de texto. Los flujos de datos son la materia prima sobre la que realizan su trabajo las utilidades GNU, las utilidades principales de Linux y muchas otras herramientas de línea de comandos.
Como su nombre lo indica, un flujo de datos es un flujo de datos, especialmente datos de texto, que se pasan de un archivo, dispositivo o programa a otro mediante STDIO. Este capítulo presenta el uso de tuberías para conectar flujos de datos de un programa de utilidad a otro usando STDIO. Aprenderá que la función de estos programas es transformar los datos de alguna manera. También aprenderá sobre el uso de la redirección para redirigir los datos a un archivo.
La terminal de Linux
- Los 7 mejores emuladores de terminal para Linux
- 10 herramientas de línea de comandos para el análisis de datos en Linux
- Descargar ahora:hoja de referencia de SSH
- Hoja de trucos de comandos avanzados de Linux
- Tutoriales de línea de comandos de Linux
Utilizo el término "transformar" junto con estos programas porque la tarea principal de cada uno es transformar los datos entrantes de STDIO de una manera específica según lo previsto por el administrador del sistema y enviar los datos transformados a STDOUT para su posible uso por parte de otro programa transformador. o redirección a un archivo.
El término estándar, "filtros", implica algo con lo que no estoy de acuerdo. Por definición, un filtro es un dispositivo o una herramienta que elimina algo, como un filtro de aire que elimina los contaminantes del aire para que el motor de combustión interna de su automóvil no muera con esas partículas. En mis clases de química de la escuela secundaria y la universidad, se usaba papel de filtro para eliminar partículas de un líquido. El filtro de aire del sistema HVAC de mi casa elimina las partículas que no quiero respirar.
Aunque a veces filtran datos no deseados de una secuencia, prefiero el término "transformadores" porque estas utilidades hacen mucho más. Pueden agregar datos a un flujo, modificar los datos de maneras asombrosas, ordenarlos, reorganizar los datos en cada línea, realizar operaciones basadas en el contenido del flujo de datos y mucho más. Siéntase libre de usar el término que prefiera, pero prefiero transformadores. Espero estar solo en esto.
Los flujos de datos se pueden manipular insertando transformadores en el flujo mediante tuberías. Cada programa transformador es utilizado por el administrador del sistema para realizar alguna operación en los datos en el flujo, cambiando así su contenido de alguna manera. La redirección se puede usar al final de la canalización para dirigir el flujo de datos a un archivo. Como se mencionó, ese archivo podría ser un archivo de datos real en el disco duro o un archivo de dispositivo, como una partición de disco, una impresora, una terminal, una pseudo-terminal o cualquier otro dispositivo conectado a una computadora.
La capacidad de manipular estos flujos de datos utilizando estos pequeños pero poderosos programas transformadores es fundamental para el poder de la interfaz de línea de comandos de Linux. Muchas de las utilidades principales son programas transformadores y utilizan STDIO.
En los mundos de Unix y Linux, un flujo es un flujo de datos de texto que se origina en alguna fuente; el flujo puede fluir a uno o más programas que lo transforman de alguna manera, y luego puede almacenarse en un archivo o mostrarse en una sesión de terminal. Como administrador de sistemas, su trabajo está íntimamente relacionado con la manipulación de la creación y el flujo de estos flujos de datos. En esta publicación, exploraremos los flujos de datos:qué son, cómo crearlos y un poco sobre cómo usarlos.
Flujos de texto:una interfaz universal
El uso de Entrada/Salida Estándar (STDIO) para la entrada y salida del programa es una base clave de la forma de hacer las cosas de Linux. STDIO se desarrolló por primera vez para Unix y desde entonces ha llegado a la mayoría de los demás sistemas operativos, incluidos DOS, Windows y Linux.
“Esta es la filosofía de Unix:escribir programas que hagan una cosa y la hagan bien. Escribir programas para trabajar juntos. Escribe programas para manejar flujos de texto, porque esa es una interfaz universal”.
— Doug McIlroy, Fundamentos de la filosofía Unix
ESTDIO
STDIO fue desarrollado por Ken Thompson como parte de la infraestructura requerida para implementar tuberías en las primeras versiones de Unix. Los programas que implementan STDIO utilizan identificadores de archivos estandarizados para la entrada y la salida en lugar de archivos almacenados en un disco u otro medio de grabación. STDIO se describe mejor como un flujo de datos almacenados en búfer, y su función principal es transmitir datos desde la salida de un programa, archivo o dispositivo a la entrada de otro programa, archivo o dispositivo.
Hay tres flujos de datos STDIO, cada uno de los cuales se abre automáticamente como un archivo al iniciar un programa, bueno, aquellos programas que usan STDIO. Cada flujo de datos STDIO está asociado con un identificador de archivo, que es solo un conjunto de metadatos que describen los atributos del archivo. Los identificadores de archivo 0, 1 y 2 se definen explícitamente por convención y larga práctica como STDIN, STDOUT y STDERR, respectivamente.
STDIN, identificador de archivo 0 , es una entrada estándar que generalmente se ingresa desde el teclado. STDIN se puede redirigir desde cualquier archivo, incluidos los archivos del dispositivo, en lugar del teclado. No es común necesitar redirigir STDIN, pero se puede hacer.
STDOUT, identificador de archivo 1 , es una salida estándar que envía el flujo de datos a la pantalla de forma predeterminada. Es común redirigir STDOUT a un archivo o canalizarlo a otro programa para su posterior procesamiento.
STDERR, identificador de archivo 2 . El flujo de datos para STDERR también suele enviarse a la pantalla.
Si STDOUT se redirige a un archivo, STDERR continúa apareciendo en la pantalla. Esto asegura que cuando el flujo de datos en sí no se muestre en el terminal, STDERR sí, lo que garantiza que el usuario verá cualquier error que resulte de la ejecución del programa. STDERR también se puede redirigir al mismo o pasar al siguiente programa de transformadores en una canalización.
STDIO se implementa como una biblioteca C, stdio.h , que se puede incluir en el código fuente de los programas para que se pueda compilar en el ejecutable resultante.
Transmisiones simples
Puede realizar los siguientes experimentos de forma segura en el /tmp directorio de su servidor Linux. Como usuario raíz, haga /tmp el PWD, cree un directorio de prueba y luego convierta el nuevo directorio en el PWD.
# cd /tmp ; mkdir test ; cd test
Ingrese y ejecute el siguiente programa de línea de comandos para crear algunos archivos con contenido en la unidad. Usamos el dmesg comando simplemente para proporcionar datos para que los archivos los contengan. Los contenidos no importan tanto como el hecho de que cada archivo tenga algo de contenido.
# for I in 0 1 2 3 4 5 6 7 8 9 ; do dmesg > file$I.txt ; done Verifique que ahora hay al menos 10 archivos en /tmp/ con los nombres file0.txt a través de file9.txt .
# ll
total 1320
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file0.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file1.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file2.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file3.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file4.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file5.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file6.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file7.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file8.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file9.txt
Hemos generado flujos de datos usando dmesg comando, que fue redirigido a una serie de archivos. La mayoría de las utilidades principales usan STDIO como su flujo de salida y aquellas que generan flujos de datos, en lugar de actuar para transformar el flujo de datos de alguna manera, se pueden usar para crear los flujos de datos que usaremos para nuestros experimentos. Los flujos de datos pueden ser tan cortos como una línea o incluso un solo carácter, y tan largos como sea necesario.
Explorando el disco duro
Ahora es el momento de hacer un poco de exploración. En este experimento, veremos algunas de las estructuras del sistema de archivos.
Comencemos con algo simple. Debería estar al menos algo familiarizado con el dd dominio. Conocido oficialmente como "volcado de disco", muchos administradores de sistemas lo llaman "destructor de disco" por una buena razón. Muchos de nosotros hemos destruido sin darnos cuenta el contenido de un disco duro completo o una partición usando el dd dominio. Es por eso que pasaremos el rato en el /tmp/test directorio para realizar algunos de estos experimentos.
A pesar de su reputación, dd puede ser bastante útil para explorar varios tipos de medios de almacenamiento, discos duros y particiones. También lo usaremos como una herramienta para explorar otros aspectos de Linux.
Inicie sesión en una sesión de terminal como root si aún no lo es. Primero necesitamos determinar el archivo especial de dispositivo para su disco duro usando lsblk comando.
[root@studentvm1 test]# lsblk -i
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 60G 0 disk
|-sda1 8:1 0 1G 0 part /boot
`-sda2 8:2 0 59G 0 part
|-fedora_studentvm1-pool00_tmeta 253:0 0 4M 0 lvm
| `-fedora_studentvm1-pool00-tpool 253:2 0 2G 0 lvm
| |-fedora_studentvm1-root 253:3 0 2G 0 lvm /
| `-fedora_studentvm1-pool00 253:6 0 2G 0 lvm
|-fedora_studentvm1-pool00_tdata 253:1 0 2G 0 lvm
| `-fedora_studentvm1-pool00-tpool 253:2 0 2G 0 lvm
| |-fedora_studentvm1-root 253:3 0 2G 0 lvm /
| `-fedora_studentvm1-pool00 253:6 0 2G 0 lvm
|-fedora_studentvm1-swap 253:4 0 10G 0 lvm [SWAP]
|-fedora_studentvm1-usr 253:5 0 15G 0 lvm /usr
|-fedora_studentvm1-home 253:7 0 2G 0 lvm /home
|-fedora_studentvm1-var 253:8 0 10G 0 lvm /var
`-fedora_studentvm1-tmp 253:9 0 5G 0 lvm /tmp
sr0 11:0 1 1024M 0 rom
Podemos ver a partir de esto que solo hay un disco duro en este host, que el archivo especial del dispositivo asociado con él es /dev/sda , y que tiene dos particiones. El /dev/sda1 partición es la partición de arranque, y el /dev/sda2 La partición contiene un grupo de volúmenes en el que se han creado el resto de los volúmenes lógicos del host.
Como root en la sesión de terminal, use el dd comando para ver el registro de arranque del disco duro, suponiendo que esté asignado a /dev/sda dispositivo. El bs= el argumento no es lo que podrías pensar; simplemente especifica el tamaño del bloque y el count= El argumento especifica el número de bloques para volcar a STDIO. El if= El argumento especifica la fuente del flujo de datos, en este caso, /dev/sda dispositivo. Tenga en cuenta que no estamos mirando el primer bloque de la partición, estamos mirando el primer bloque del disco duro.
[root@studentvm1 test]# dd if=/dev/sda bs=512 count=1
�c�#�м���؎���|�#�#���!#��8#u
��#���u��#�#�#�|���t#�L#�#�|���#�����t��pt#���y|1��؎м ��d|<�t#��R�|1��D#@�D��D#�##f�#\|f�f�#`|f�\
�D#p�B�#r�p�#�K`#�#��1��������#a`���#f��u#����f1�f�TCPAf�#f�#a�&Z|�#}�#�.}�4�3}�.�#��GRUB GeomHard DiskRead Error
�#��#�<u��ܻޮ�###��� ������ �_U�1+0 records in
1+0 records out
512 bytes copied, 4.3856e-05 s, 11.7 MB/s
Esto imprime el texto del registro de inicio, que es el primer bloque en el disco, cualquier disco. En este caso, hay información sobre el sistema de archivos y, aunque es ilegible porque está almacenada en formato binario, la tabla de particiones. Si se tratara de un dispositivo de arranque, la etapa 1 de GRUB o algún otro cargador de arranque se ubicaría en este sector. Las últimas tres líneas contienen datos sobre el número de registros y bytes procesados.
Comenzando con el comienzo de /dev/sda1 , veamos algunos bloques de datos a la vez para encontrar lo que queremos. El comando es similar al anterior, excepto que hemos especificado algunos bloques más de datos para ver. Es posible que deba especificar menos bloques si su terminal no es lo suficientemente grande como para mostrar todos los datos a la vez, o puede canalizar los datos a través de la utilidad less y usarla para recorrer los datos, de cualquier manera funciona. Recuerde, estamos haciendo todo esto como usuario root porque los usuarios no root no tienen los permisos requeridos.
Ingrese el mismo comando que hizo en el experimento anterior, pero aumente el número de bloques que se mostrarán a 100, como se muestra a continuación, para mostrar más datos.
[root@studentvm1 test]# dd if=/dev/sda1 bs=512 count=100
##33��#:�##�� :o�[:o�[#��S�###�q[#
#<�#{5OZh�GJ͞#t�Ұ##boot/bootysimage/booC�dp��G'�*)�#A�##@
#�q[
�## ## ###�#���To=###<#8���#'#�###�#�����#�' �����#Xi �#��` qT���
<���
� r���� ]�#�#�##�##�##�#�##�##�##�#�##�##�#��#�#�##�#�##�##�#��#�#����# � �# �# �#
�
�#
�#
�#
�
�#
�#
�#
�
�#
�#
�#100+0 records in
100+0 records out
51200 bytes (51 kB, 50 KiB) copied, 0.00117615 s, 43.5 MB/s
Ahora prueba este comando. No reproduciré todo el flujo de datos aquí porque ocuparía una gran cantidad de espacio. Usa Ctrl-C para romper y detener el flujo de datos.
[root@studentvm1 test]# dd if=/dev/sdaEste comando produce un flujo de datos que es el contenido completo del disco duro, /dev/sda , incluido el registro de arranque, la tabla de particiones y todas las particiones y su contenido. Estos datos podrían redirigirse a un archivo para usarlos como una copia de seguridad completa a partir de la cual se puede realizar una recuperación completa. También podría enviarse directamente a otro disco duro para clonar el primero. Pero no realices este experimento en particular.
[root@studentvm1 test]# dd if=/dev/sda of=/dev/sdx
Puedes ver que el dd El comando puede ser muy útil para explorar las estructuras de varios tipos de sistemas de archivos, ubicar datos en un dispositivo de almacenamiento defectuoso y mucho más. También produce un flujo de datos en el que podemos usar las utilidades del transformador para modificar o ver.
El punto real aquí es que dd , como tantos comandos de Linux, produce un flujo de datos como salida. Ese flujo de datos se puede buscar y manipular de muchas maneras usando otras herramientas. Incluso se puede usar para copias de seguridad fantasma o duplicación de discos.
Aleatoriedad
Resulta que la aleatoriedad es algo deseable en las computadoras, ¿quién lo diría? Hay una serie de razones por las que los administradores de sistemas pueden querer generar un flujo de datos aleatorios. Una secuencia de datos aleatorios a veces es útil para sobrescribir el contenido de una partición completa, como /dev/sda1 , o incluso todo el disco duro, como en /dev/sda .
Realice este experimento como usuario no root. Ingrese este comando para imprimir un flujo interminable de datos aleatorios a STDIO.
[student@studentvm1 ~]$ cat /dev/urandomUsa Ctrl-C para romper y detener el flujo de datos. Es posible que deba usar Ctrl-C varias veces.
Los datos aleatorios también se utilizan como semilla de entrada para programas que generan contraseñas aleatorias y datos y números aleatorios para su uso en cálculos científicos y estadísticos. Cubriré la aleatoriedad y otras fuentes de datos interesantes con un poco más de detalle en el Capítulo 24:Todo es un archivo.
Sueños de pipa
Los conductos son fundamentales para nuestra capacidad de hacer cosas asombrosas en la línea de comandos, tanto que creo que es importante reconocer que fueron inventados por Douglas McIlroy durante los primeros días de Unix (¡gracias, Doug!). El sitio web de la Universidad de Princeton tiene un fragmento de una entrevista con McIlroy en la que habla sobre la creación de la tubería y los inicios de la filosofía Unix.
Observe el uso de conductos en el programa de línea de comandos simple que se muestra a continuación, que enumera cada usuario que inició sesión una sola vez, sin importar cuántos inicios de sesión tengan activos. Realice este experimento como usuario estudiante. Introduzca el comando que se muestra a continuación:
[student@studentvm1 ~]$ w | tail -n +3 | awk '{print $1}' | sort | uniq
root
student
[student@studentvm1 ~]$ Los resultados de este comando producen dos líneas de datos que muestran que tanto el usuario raíz como el alumno han iniciado sesión. No muestra cuántas veces ha iniciado sesión cada usuario. Es casi seguro que sus resultados diferirán de los míos.
Las tuberías, representadas por la barra vertical ( | ), son el pegamento sintáctico, el operador, que conecta estas utilidades de línea de comandos entre sí. Las canalizaciones permiten que la salida estándar de un comando sea "canalizada", es decir, transmitida desde la salida estándar de un comando a la entrada estándar del siguiente comando.
El operador |&se puede usar para canalizar STDERR junto con STDOUT a STDIN del siguiente comando. Esto no siempre es deseable, pero ofrece flexibilidad en la capacidad de registrar el flujo de datos STDERR para fines de determinación de problemas.
Una serie de programas conectados con conductos se denomina conducto, y los programas que utilizan STDIO se denominan oficialmente filtros, pero prefiero el término "transformadores".
Piense en cómo tendría que funcionar este programa si no pudiéramos canalizar el flujo de datos de un comando al siguiente. El primer comando realizaría su tarea en los datos y luego la salida de ese comando debería guardarse en un archivo. El siguiente comando tendría que leer el flujo de datos del archivo intermedio y realizar su modificación del flujo de datos, enviando su propia salida a un nuevo archivo de datos temporal. El tercer comando tendría que tomar sus datos del segundo archivo de datos temporales y realizar su propia manipulación del flujo de datos y luego almacenar el flujo de datos resultante en otro archivo temporal más. En cada paso, los nombres de los archivos de datos tendrían que transferirse de un comando al siguiente de alguna manera.
Ni siquiera puedo soportar pensar en eso porque es muy complejo. Recuerda:¡la simplicidad mola!
Construcción de canalizaciones
Cuando estoy haciendo algo nuevo, resolviendo un problema nuevo, por lo general no solo escribo una canalización de comando Bash completa desde cero desde la parte superior de mi cabeza. Por lo general, comienzo con solo uno o dos comandos en la tubería y construyo desde allí agregando más comandos para procesar aún más el flujo de datos. Esto me permite ver el estado del flujo de datos después de cada uno de los comandos en la canalización y hacer las correcciones necesarias.
Es posible crear canalizaciones muy complejas que pueden transformar el flujo de datos utilizando muchas utilidades diferentes que funcionan con STDIO.
Redireccionamiento
La redirección es la capacidad de redirigir el flujo de datos STDOUT de un programa a un archivo en lugar de al destino predeterminado de la pantalla. El carácter "mayor que" (> ), también conocido como "gt", es el símbolo sintáctico para la redirección de STDOUT.
La redirección de STDOUT de un comando se puede usar para crear un archivo que contenga los resultados de ese comando.
[student@studentvm1 ~]$ df -h > diskusage.txtNo hay salida a la terminal desde este comando a menos que haya un error. Esto se debe a que el flujo de datos STDOUT se redirige al archivo y STDERR todavía se dirige al dispositivo STDOUT, que es la pantalla. Puede ver el contenido del archivo que acaba de crear con el siguiente comando:
[student@studentvm1 test]# cat diskusage.txt
Filesystem Size Used Avail Use% Mounted on
devtmpfs 2.0G 0 2.0G 0% /dev
tmpfs 2.0G 0 2.0G 0% /dev/shm
tmpfs 2.0G 1.2M 2.0G 1% /run
tmpfs 2.0G 0 2.0G 0% /sys/fs/cgroup
/dev/mapper/fedora_studentvm1-root 2.0G 50M 1.8G 3% /
/dev/mapper/fedora_studentvm1-usr 15G 4.5G 9.5G 33% /usr
/dev/mapper/fedora_studentvm1-var 9.8G 1.1G 8.2G 12% /var
/dev/mapper/fedora_studentvm1-tmp 4.9G 21M 4.6G 1% /tmp
/dev/mapper/fedora_studentvm1-home 2.0G 7.2M 1.8G 1% /home
/dev/sda1 976M 221M 689M 25% /boot
tmpfs 395M 0 395M 0% /run/user/0
tmpfs 395M 12K 395M 1% /run/user/1000
Cuando se utiliza el símbolo> para redirigir el flujo de datos, se crea el archivo especificado si aún no existe. Si existe, el flujo de datos del comando sobrescribe el contenido. Puede usar símbolos de doble mayor que,>>, para agregar el nuevo flujo de datos a cualquier contenido existente en el archivo.
[student@studentvm1 ~]$ df -h >> diskusage.txt
Puedes usar cat y/o less para ver el diskusage.txt archivo para verificar que los nuevos datos se agregaron al final del archivo.
El símbolo <(menor que) redirige los datos al STDIN del programa. Es posible que desee usar este método para ingresar datos de un archivo a STDIN de un comando que no toma un nombre de archivo como argumento pero que usa STDIN. Aunque las fuentes de entrada se pueden redirigir a STDIN, como un archivo que se usa como entrada para grep, generalmente no es necesario ya que grep también toma un nombre de archivo como argumento para especificar la fuente de entrada. La mayoría de los otros comandos también toman un nombre de archivo como argumento para su fuente de entrada.
Solo dando vueltas
El grep El comando se utiliza para seleccionar líneas que coincidan con un patrón específico de un flujo de datos. grep es una de las utilidades de transformadores más utilizadas y se puede utilizar de formas muy creativas e interesantes. El grep El comando es uno de los pocos que puede llamarse correctamente filtro porque filtra todas las líneas del flujo de datos que no desea; deja solo las líneas que desea en el flujo de datos restante.
Si el PWD no es el /tmp/test directorio, hágalo así. Primero creemos una secuencia de datos aleatorios para almacenar en un archivo. En este caso, queremos datos algo menos aleatorios que estarían limitados a caracteres imprimibles. Un buen programa generador de contraseñas puede hacer esto. El siguiente programa (puede que tenga que instalar pwgen si aún no lo está) crea un archivo que contiene 50,000 contraseñas que tienen 80 caracteres de largo usando cada carácter imprimible. Pruébelo sin redirigir a random.txt primero para ver cómo se ve y luego hágalo una vez redirigiendo el flujo de datos de salida al archivo.
$ pwgen -sy 80 50000 > random.txt
Teniendo en cuenta que hay tantas contraseñas, es muy probable que algunas cadenas de caracteres sean iguales. Primero, cat el aleatorio.txt archivo, luego use el grep comando para ubicar algunas cadenas cortas seleccionadas al azar de las últimas diez contraseñas en la pantalla. Vi la palabra "ver" en una de esas diez contraseñas, así que mi comando se veía así:grep see random.txt , y puede probar eso, pero también debe elegir algunas cadenas propias para verificar. Las cadenas cortas de dos a cuatro caracteres funcionan mejor.
$ grep see random.txt
R=p)'s/~0}wr~2(OqaL.S7DNyxlmO69`"12u]h@rp[D2%3}1b87+>Vk,;4a0hX]d7see;1%9|wMp6Yl.
bSM_mt_hPy|YZ1<TY/Hu5{g#mQ<u_(@8B5Vt?w%i-&C>NU@[;zV2-see)>(BSK~n5mmb9~h)yx{a&$_e
cjR1QWZwEgl48[3i-(^x9D=v)seeYT2R#M:>wDh?Tn$]HZU7}j!7bIiIr^cI.DI)W0D"'[email protected]
z=tXcjVv^G\nW`,y=bED]d|7%s6iYT^a^Bvsee:v\UmWT02|P|nq%A*;+Ng[$S%*s)-ls"dUfo|0P5+n
Resumen
Es el uso de canalizaciones y redirección lo que permite muchas de las sorprendentes y poderosas tareas que se pueden realizar con flujos de datos en la línea de comandos de Linux. Son conductos que transportan flujos de datos STDIO de un programa o archivo a otro. La capacidad de canalizar flujos de datos a través de uno o más programas transformadores admite una manipulación potente y flexible de los datos en esos flujos.
Cada uno de los programas en los conductos demostrados en los experimentos es pequeño y cada uno hace una cosa bien. También son transformadores; es decir, toman la entrada estándar, la procesan de alguna manera y luego envían el resultado a la salida estándar. La implementación de estos programas como transformadores para enviar flujos de datos procesados desde su propia salida estándar a la entrada estándar de los otros programas es complementaria y necesaria para la implementación de tuberías como una herramienta de Linux.
STDIO no es más que flujos de datos. Estos datos pueden ser casi cualquier cosa, desde la salida de un comando para enumerar los archivos en un directorio, o un flujo interminable de datos desde un dispositivo especial como /dev/urandom , o incluso un flujo que contiene todos los datos sin procesar de un disco duro o una partición.
Cualquier dispositivo en una computadora con Linux puede tratarse como un flujo de datos. Puede usar herramientas ordinarias como dd y cat para volcar datos de un dispositivo en un flujo de datos STDIO que se puede procesar con otras herramientas ordinarias de Linux.