Redirecionamento de Entrada e Saída no Linux

Introdução

Neste laboratório, você aprenderá as técnicas fundamentais para redirecionar a entrada e a saída no shell do Linux. Você explorará como controlar o fluxo de dados dos comandos manipulando os três fluxos padrão: saída padrão (stdout), erro padrão (stderr) e entrada padrão (stdin). Este laboratório oferece prática prática com operadores de redirecionamento essenciais, permitindo que você salve a saída de comandos, gerencie mensagens de erro e forneça entrada para comandos a partir de arquivos.

Ao longo dos exercícios, você usará o operador > para enviar a saída de um comando para um arquivo, sobrescrevendo o conteúdo existente, e o operador >> para anexar a saída sem perder dados. Você também aprenderá a redirecionar especificamente mensagens de erro usando 2> e como combinar a saída padrão e o erro padrão em um único arquivo. Por fim, você usará o comando tee para exibir simultaneamente a saída na tela e salvá-la em um arquivo, e praticará o redirecionamento da entrada padrão usando o operador < para fazer com que um comando leia de um arquivo em vez do teclado.

Redirecionar a Saída Padrão com o Operador >

Nesta etapa, você aprenderá como redirecionar a saída padrão de um comando. Em um shell Linux, a maioria dos comandos produz algum tipo de saída. Por padrão, essa saída, conhecida como "Saída Padrão" (ou stdout), é exibida na tela do seu terminal. No entanto, você pode redirecionar essa saída para um arquivo usando o operador >. Isso é útil para salvar resultados de comandos, criar arquivos de log ou gerar relatórios.

Primeiro, vamos executar um comando simples e ver sua saída no terminal.

echo "Hello from LabEx"

Você deverá ver a seguinte saída diretamente no seu terminal:

Hello from LabEx

Agora, vamos redirecionar essa saída para um arquivo. Usaremos o operador > seguido de um nome de arquivo. Isso instrui o shell a enviar a saída do comando echo para um arquivo chamado hello.txt no seu diretório atual (~/project).

Execute o seguinte comando:

echo "Hello from LabEx" > hello.txt

Observe que, desta vez, você não vê nenhuma saída no terminal. Isso ocorre porque a saída foi enviada para o arquivo hello.txt. Você pode verificar o conteúdo do arquivo usando o comando cat:

cat hello.txt

A saída mostrará o texto que foi redirecionado:

Hello from LabEx

O operador > criará o arquivo se ele não existir. Tenha cuidado, se o arquivo já existir, o operador > irá sobrescrever todo o seu conteúdo sem qualquer aviso. Vamos ver isso na prática.

Primeiro, vamos listar o conteúdo do diretório atual e salvá-lo em um novo arquivo chamado file_list.txt.

ls -l > file_list.txt

Agora, visualize o conteúdo de file_list.txt:

cat file_list.txt

Você verá uma listagem dos arquivos no diretório do seu projeto, que deve ser algo parecido com isto:

total 4
-rw-rw-r-- 1 labex labex  0 Jun 25 14:56 file_list.txt
-rw-rw-r-- 1 labex labex 17 Jun 25 14:56 hello.txt

Agora, vamos executar um comando diferente e redirecionar sua saída para o mesmo arquivo, file_list.txt.

echo "This is new content." > file_list.txt

Se você verificar o conteúdo de file_list.txt novamente, verá que a listagem de arquivos original foi substituída.

cat file_list.txt

A saída agora é:

This is new content.

Isso demonstra o comportamento de sobrescrita do operador >. Na próxima etapa, você aprenderá como anexar a saída a um arquivo sem sobrescrevê-lo.

Anexar a Saída Padrão com o Operador >>

Nesta etapa, você aprenderá como adicionar saída ao final de um arquivo sem excluir seu conteúdo existente. Na etapa anterior, você viu que o operador > sobrescreve o arquivo de destino. Para evitar isso, você pode usar o operador de anexo, >>. Este operador é extremamente útil para tarefas como manter um arquivo de log contínuo, onde você deseja adicionar novas entradas ao longo do tempo.

Vamos começar criando um arquivo com algum conteúdo inicial. Vamos chamá-lo de greetings.txt.

echo "Hello, this is the first line." > greetings.txt

Agora, verifique seu conteúdo:

cat greetings.txt

A saída deve ser:

Hello, this is the first line.

Em seguida, em vez de sobrescrever o arquivo, vamos anexar uma nova linha a ele usando o operador >>.

echo "This is the second line, appended." >> greetings.txt

Verifique o conteúdo de greetings.txt novamente.

cat greetings.txt

Desta vez, você verá que a nova linha foi adicionada após o conteúdo original:

Hello, this is the first line.
This is the second line, appended.

O operador >> é perfeito para criar arquivos de log. Vamos criar um arquivo de log simples chamado activity.log e adicionar um carimbo de data/hora a ele usando o comando date.

date > activity.log

Agora, vamos anexar outro carimbo de data/hora ao mesmo arquivo.

date >> activity.log

Visualize o arquivo activity.log final para ver ambas as entradas.

cat activity.log

A saída mostrará dois carimbos de data/hora, demonstrando que o segundo comando anexou sua saída em vez de sobrescrever o arquivo. Os horários exatos variam.

Wed Jun 25 14:56:53 CST 2025
Wed Jun 25 14:56:56 CST 2025

Isso mostra como o >> preserva os dados existentes e adiciona novos dados ao final de um arquivo, tornando-o uma maneira segura de atualizar arquivos com novas informações.

Redirecionar o Erro Padrão com o Operador 2>

Nesta etapa, você aprenderá a gerenciar mensagens de erro. Além da saída padrão (stdout), os comandos também produzem outro tipo de saída chamada "Erro Padrão" (stderr). Este é um fluxo separado usado especificamente para mensagens de erro e diagnósticos. Por padrão, tanto stdout quanto stderr são exibidos no seu terminal, mas os operadores de redirecionamento que você aprendeu até agora (> e >>) afetam apenas o stdout.

Para redirecionar o stderr, você precisa especificar seu descritor de arquivo, que é 2. O operador > é, na verdade, um atalho para 1>, onde 1 é o descritor de arquivo para stdout. Portanto, para redirecionar o stderr, você usa 2>.

Vamos gerar um erro para ver isso em ação. Tentaremos listar um arquivo que não existe.

ls non_existent_file

Este comando falhará e imprimirá uma mensagem de erro no seu terminal:

ls: cannot access 'non_existent_file': No such file or directory

Agora, vamos tentar redirecionar isso usando o operador padrão >.

ls non_existent_file > output.txt

Observe que a mensagem de erro ainda é impressa no terminal. O operador > não a capturou. Se você verificar o arquivo output.txt, verá que ele está vazio.

cat output.txt

O comando não produz saída porque nenhuma saída padrão foi gerada, apenas erro padrão.

Agora, vamos redirecionar corretamente o erro padrão para um arquivo chamado error.log usando 2>.

ls non_existent_file 2> error.log

Desta vez, nenhuma mensagem aparece no terminal. O erro foi redirecionado com sucesso. Você pode visualizar o conteúdo de error.log para ver a mensagem capturada.

cat error.log

A saída será a mensagem de erro do comando ls:

ls: cannot access 'non_existent_file': No such file or directory

Assim como o >> anexa a saída padrão, você pode usar 2>> para anexar o erro padrão a um arquivo. Vamos tentar listar outro arquivo inexistente e anexar o erro ao nosso error.log.

ls another_fake_file 2>> error.log

Agora, verifique o conteúdo de error.log novamente.

cat error.log

Você verá que a nova mensagem de erro foi adicionada ao final do arquivo.

ls: cannot access 'non_existent_file': No such file or directory
ls: cannot access 'another_fake_file': No such file or directory

Essa técnica é muito útil para separar a saída normal das mensagens de erro, permitindo que você registre erros para revisão posterior sem poluir seus arquivos de saída principais.

Redirecionar Tanto stdout Quanto stderr para um Único Arquivo

Nesta etapa, você aprenderá como capturar toda a saída de um comando — tanto a saída padrão quanto o erro padrão — em um único arquivo. Isso é particularmente útil quando você deseja um registro completo da execução de um script ou comando, incluindo quaisquer erros que tenham ocorrido.

Vamos usar um comando que produz tanto stdout quanto stderr. Tentaremos listar um arquivo que existe (/etc/passwd) e um que não existe (non_existent_file).

ls -l /etc/passwd non_existent_file

Você verá dois tipos de saída no seu terminal. A primeira linha é o erro padrão e a segunda é a saída padrão.

ls: cannot access 'non_existent_file': No such file or directory
-rw-r--r-- 1 root root 1916 Jul 18  2024 /etc/passwd

Se você tentar redirecionar isso usando apenas > para stdout, a mensagem de erro ainda aparecerá na tela.

ls -l /etc/passwd non_existent_file > output_only.txt

Saída no terminal:

ls: cannot access 'non_existent_file': No such file or directory

E o arquivo output_only.txt conterá apenas a saída padrão:

cat output_only.txt

-rw-r--r-- 1 root root 1916 Jul 18  2024 /etc/passwd

Para redirecionar ambos os fluxos para um único arquivo, você pode usar o operador &>. Este é um atalho conveniente que envia tanto o stdout (descritor de arquivo 1) quanto o stderr (descritor de arquivo 2) para o arquivo especificado.

Vamos testar. Redirecionaremos toda a saída para um arquivo chamado combined.log.

ls -l /etc/passwd non_existent_file &> combined.log

Desta vez, nada é impresso no terminal. Toda a saída foi capturada em combined.log. Vamos visualizar seu conteúdo:

cat combined.log

Você verá que o arquivo contém tanto a saída padrão quanto o erro padrão:

ls: cannot access 'non_existent_file': No such file or directory
-rw-r--r-- 1 root root 1916 Jul 18  2024 /etc/passwd

Existe também uma sintaxe mais tradicional, porém um pouco mais complexa, para obter o mesmo resultado: > arquivo 2>&1. Vamos detalhá-la:

• > arquivo: Redireciona a saída padrão (descritor de arquivo 1) para o arquivo.
• 2>&1: Redireciona o erro padrão (descritor de arquivo 2) para o mesmo local da saída padrão (descritor de arquivo 1). Como o stdout já está indo para o arquivo, o stderr também é enviado para lá.

Vamos tentar este método, salvando a saída em combined_traditional.log.

ls -l /etc/passwd non_existent_file > combined_traditional.log 2>&1

Novamente, nenhuma saída aparece no terminal. A verificação do conteúdo do arquivo mostra o mesmo resultado:

cat combined_traditional.log

ls: cannot access 'non_existent_file': No such file or directory
-rw-r--r-- 1 root root 1916 Jul 18  2024 /etc/passwd

Embora o &> seja mais curto e geralmente preferido, você encontrará frequentemente o 2>&1 em scripts mais antigos, por isso é importante entender o que ele faz. Para anexar ambos os fluxos, você pode usar &>> ou >> arquivo 2>&1.

Usar tee para Dividir a Saída e Redirecionar a Entrada Padrão com <

Nesta etapa final, você explorará dois conceitos de redirecionamento complementares: dividir a saída com o comando tee e fornecer entrada para um comando a partir de um arquivo usando o operador <.

Dividindo a Saída com tee

Às vezes, você deseja salvar a saída de um comando em um arquivo e, ao mesmo tempo, visualizá-la no terminal. Os operadores > e >> redirecionam a saída exclusivamente para um arquivo, ocultando-a da tela. O comando tee resolve isso dividindo a saída, enviando-a tanto para um arquivo quanto para a saída padrão (sua tela). Seu nome vem do conector em "T" usado em encanamentos, que divide um fluxo em dois caminhos.

Vamos vê-lo em ação. Listaremos o conteúdo do diretório /etc/ e usaremos o tee para exibir a lista na tela e salvá-la em um arquivo chamado etc_listing.txt.

ls /etc/ | tee etc_listing.txt

Você verá a listagem completa do diretório impressa no seu terminal. Ao mesmo tempo, o comando tee gravou exatamente a mesma saída em etc_listing.txt. Você pode verificar isso:

cat etc_listing.txt

O conteúdo do arquivo corresponderá ao que você viu na tela.

Por padrão, o tee sobrescreve o arquivo de destino. Para anexar a um arquivo, use a opção -a. Isso é muito útil para logs. Vamos criar um arquivo de log e anexar duas entradas.

date | tee system_log.txt
echo "User labex performed a system check." | tee -a system_log.txt

O primeiro comando cria o system_log.txt com a data atual. O segundo comando, usando tee -a, anexa uma nova linha sem excluir a data. Vamos verificar o arquivo final:

cat system_log.txt

A saída mostrará ambas as linhas:

Wed Jun 25 14:56:53 CST 2025
User labex performed a system check.

Redirecionando a Entrada Padrão com <

Agora vamos olhar para o oposto do redirecionamento de saída: o redirecionamento de entrada padrão (stdin). Muitos comandos, como sort, wc ou cat, podem ler dados do stdin (geralmente o seu teclado). O operador < permite que você instrua um comando a obter sua entrada de um arquivo.

Primeiro, vamos criar um arquivo simples com uma lista de itens. Vamos chamá-lo de items.txt.

echo "banana" > items.txt
echo "apple" >> items.txt
echo "cherry" >> items.txt

Agora temos um arquivo items.txt com três itens não ordenados. O comando sort pode ordenar linhas de texto. Vamos usar o < para alimentar o comando sort com o conteúdo de items.txt.

sort < items.txt

O comando lerá o conteúdo de items.txt como sua entrada, irá ordená-lo e imprimirá o resultado em sua saída padrão (o terminal):

apple
banana
cherry

Isso é funcionalmente semelhante a executar sort items.txt, mas demonstra o poderoso conceito de redirecionar um arquivo para a entrada padrão de um comando. Isso se torna essencial ao trabalhar com comandos que apenas conseguem ler do stdin e não aceitam um nome de arquivo como argumento.

Como exemplo final, considere cat < items.txt. Isso diz ao cat para ler sua entrada de items.txt e, como o trabalho do cat é imprimir sua entrada na sua saída, ele exibe o conteúdo do arquivo na tela.

cat < items.txt

Isso conclui nossa exploração sobre o redirecionamento básico de E/S no Linux. Agora você possui as ferramentas para controlar de onde seus comandos recebem entrada e para onde suas saídas são enviadas.

Resumo

Neste laboratório, você aprendeu os fundamentos do redirecionamento de saída de comandos no Linux. Você começou usando o operador > para enviar a saída padrão (stdout) de um comando para um arquivo, observando que este operador sobrescreverá o arquivo de destino se ele já existir. Para evitar a sobrescrita, você usou o operador >> para anexar a saída ao final de um arquivo. Você também praticou o redirecionamento do erro padrão (stderr) para um arquivo usando o operador 2>, o que é útil para capturar mensagens de erro separadamente da saída padrão.

Além disso, o laboratório demonstrou como combinar esses conceitos redirecionando tanto o stdout quanto o stderr para um único arquivo para um log abrangente. Você explorou o comando tee como um método para dividir a saída, permitindo que ela seja salva em um arquivo enquanto é exibida simultaneamente no terminal. Por fim, você aprendeu a redirecionar a entrada padrão (stdin) usando o operador <, permitindo que um comando leia sua entrada de um arquivo em vez do teclado.