Editar Arquivos de Texto no Red Hat Enterprise Linux (RHEL) - Guia Completo

Introdução

Neste laboratório, você adquirirá habilidades essenciais para gerenciar arquivos de texto e personalizar seu ambiente de shell no Linux. Você aprenderá como redirecionar a saída padrão (standard output) e os fluxos de erro (error streams) para arquivos, combinar diferentes fluxos e construir pipelines de comandos (command pipelines) poderosos para automatizar tarefas.

Além disso, você explorará os fundamentos da edição de arquivos de texto usando o Vim, um editor de texto amplamente utilizado e poderoso. Por fim, você aprenderá a configurar e utilizar variáveis de shell e aliases para personalizar sua experiência na linha de comando e aumentar a produtividade.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 86%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Redirecionar a Saída Padrão para Arquivos

Nesta etapa, você aprenderá como redirecionar a saída padrão (standard output) de comandos para arquivos. Esta é uma habilidade fundamental na administração de sistemas Linux, permitindo que você capture os resultados dos comandos para análise posterior, registro (logging) ou processamento adicional.

O shell usa descritores de arquivo (file descriptors) especiais para gerenciar entrada e saída. Os mais comuns são:

0: Entrada Padrão (stdin) - Tipicamente do teclado.
1: Saída Padrão (stdout) - Tipicamente para a tela do terminal.
2: Erro Padrão (stderr) - Tipicamente para a tela do terminal para mensagens de erro.

Nós focaremos em redirecionar stdout nesta seção.

Sobrescrever um Arquivo com `>`

O operador > redireciona a saída padrão de um comando para um arquivo especificado. Se o arquivo não existir, ele será criado. Se o arquivo já existir, seu conteúdo será sobrescrito.

Vamos começar criando um arquivo de texto simples com a data e hora atuais.

Primeiro, certifique-se de estar no diretório project da sua pasta pessoal.
```
cd ~/project
```
```
[labex@host project]$
```
Agora, use o comando date e redirecione sua saída para um novo arquivo chamado current_datetime.txt.
```
date > current_datetime.txt
```
Este comando executará date, mas em vez de imprimir a data no seu terminal, ele a salvará em current_datetime.txt.
Verifique o conteúdo do arquivo usando o comando cat.
```
cat current_datetime.txt
```
```
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY
```
A saída mostrará a data e hora atuais, semelhante ao exemplo acima.
Agora, vamos tentar redirecionar a saída de echo para o mesmo arquivo. Isso irá sobrescrever o conteúdo anterior.
```
echo "This is a new line of text." > current_datetime.txt
```
Verifique o conteúdo do arquivo novamente.
```
cat current_datetime.txt
```
```
This is a new line of text.
```
Como você pode ver, a data e hora originais foram substituídas pela nova linha de texto.

Anexar a um Arquivo com `>>`

O operador >> redireciona a saída padrão de um comando para um arquivo especificado, anexando o novo conteúdo ao final do arquivo. Se o arquivo não existir, ele será criado.

Vamos anexar mais conteúdo ao nosso arquivo current_datetime.txt.

Anexe outra linha de texto a current_datetime.txt.

echo "This line is appended." >> current_datetime.txt

Visualize o conteúdo do arquivo.
```
cat current_datetime.txt
```
```
This is a new line of text.
This line is appended.
```
Observe que a nova linha foi adicionada após o conteúdo existente.
Vamos anexar a data e hora atuais novamente.
```
date >> current_datetime.txt
```

Verifique o conteúdo do arquivo mais uma vez.

cat current_datetime.txt

This is a new line of text.
This line is appended.
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY

A data e hora estão agora no final do arquivo.

Redirecionando a Saída de Outros Comandos

Você pode redirecionar a saída de quase qualquer comando. Vamos tentar redirecionar a saída de ls e wc.

Redirecione a saída de ls -l (formato de listagem longa) para um arquivo chamado file_list.txt.
```
ls -l > file_list.txt
```
Inspecione o conteúdo de file_list.txt.
```
cat file_list.txt
```
```
total 4
-rw-r--r-- 1 labex labex 80 Jun  4 07:04 current_datetime.txt
-rw-r--r-- 1 labex labex  0 Jun  4 07:04 file_list.txt
```
Este arquivo agora contém a listagem detalhada dos arquivos em seu diretório atual. Os tamanhos exatos dos arquivos e os timestamps variarão com base em quando você executar os comandos.
Agora, vamos contar o número de linhas em file_list.txt usando wc -l e redirecionar essa contagem para outro arquivo, line_count.txt.
```
wc -l file_list.txt > line_count.txt
```
Visualize o conteúdo de line_count.txt.
```
cat line_count.txt
```
```
3 file_list.txt
```
A saída mostra que file_list.txt tem 3 linhas (incluindo a linha total e as duas entradas de arquivo).

Esta conclui a primeira parte do redirecionamento da saída padrão. Você aprendeu como criar e sobrescrever arquivos usando > e anexar a eles usando >>.

Redirecionar Erros Padrão e Combinar Fluxos

Nesta etapa, você aprenderá como redirecionar o erro padrão (stderr) e como combinar stdout e stderr em um único fluxo. Isso é crucial para gerenciar mensagens de erro geradas por comandos, permitindo que você as registre (log) ou descarte conforme necessário.

Lembre-se que stderr é o descritor de arquivo 2. Usamos 2> para redirecionar mensagens de erro.

Redirecionando o Erro Padrão para um Arquivo

Às vezes, os comandos produzem mensagens de erro que você deseja capturar separadamente de sua saída padrão.

Certifique-se de estar no seu diretório ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Vamos tentar listar o conteúdo de um diretório inexistente. Isso gerará uma mensagem de erro.
```
ls non_existent_directory
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Você pode ver a mensagem de erro impressa diretamente no terminal.
Agora, vamos redirecionar esta mensagem de erro para um arquivo chamado errors.log.
```
ls non_existent_directory 2> errors.log
```
Desta vez, você não verá a mensagem de erro no seu terminal.
Verifique o conteúdo de errors.log.
```
cat errors.log
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
A mensagem de erro agora está armazenada no arquivo.

Descartando o Erro Padrão

Frequentemente, você pode querer executar um comando que produz mensagens de erro ruidosas das quais você não se importa. Nesses casos, você pode redirecionar stderr para /dev/null. /dev/null é um arquivo de dispositivo especial que descarta todos os dados escritos nele.

Tente o comando ls com o diretório inexistente novamente, mas desta vez, descarte o erro.
```
ls non_existent_directory 2> /dev/null
```
Você não verá nenhuma saída no terminal, e nenhuma mensagem de erro é salva em um arquivo.

Combinando Saída Padrão e Erro Padrão

Existem situações em que você deseja capturar tanto stdout quanto stderr no mesmo arquivo. Isso pode ser feito de algumas maneiras.

Método 1: `> file 2>&1`

Este método redireciona stdout para um arquivo e, em seguida, redireciona stderr para o mesmo local que stdout. A ordem 2>&1 é importante: significa "redirecionar o descritor de arquivo 2 (stderr) para o mesmo lugar que o descritor de arquivo 1 (stdout)".

Vamos criar um comando que produza tanto saída padrão quanto erro padrão. Usaremos find para procurar um arquivo em um diretório onde temos permissões e em um diretório onde não temos.
```
find ~/project /root -name "current_datetime.txt" > combined_output.log 2>&1
```
Aqui, find ~/project -name "current_datetime.txt" produzirá stdout (se encontrado), e find /root -name "current_datetime.txt" provavelmente produzirá stderr devido a problemas de permissão.
Examine o arquivo combined_output.log.
```
cat combined_output.log
```
```
/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
```
Você pode ver que tanto a saída bem-sucedida (o caminho para o arquivo) quanto a mensagem de erro são capturadas no mesmo arquivo.

Método 2: `&> file` (Específico do Bash)

O Bash fornece uma abreviação para combinar stdout e stderr em um arquivo: &>. Isso é equivalente a > file 2>&1.

Vamos tentar o mesmo comando find usando a abreviação &>.

find ~/project /root -name "file_list.txt" &> combined_output_shorthand.log

Verifique o conteúdo de combined_output_shorthand.log.
```
cat combined_output_shorthand.log
```
```
/home/labex/project/file_list.txt
find: ‘/root’: Permission denied
```
O resultado é o mesmo que o método anterior, demonstrando a conveniência de &>.

Anexando Fluxos Combinados

Assim como com stdout, você pode anexar stdout e stderr combinados a um arquivo usando >> file 2>&1 ou &>> file.

Anexe mais saída e erros a combined_output.log.

find ~/project /root -name "line_count.txt" >> combined_output.log 2>&1

Visualize o combined_output.log atualizado.

cat combined_output.log

/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
/home/labex/project/line_count.txt
find: ‘/root’: Permission denied

A nova saída e os erros são anexados ao conteúdo existente.

Você agora aprendeu com sucesso como redirecionar o erro padrão e como combinar a saída padrão e o erro padrão em um único arquivo. Este conhecimento é essencial para tarefas robustas de scripting e administração de sistemas.

Construir e Compreender Pipelines de Comandos

Nesta etapa, você aprenderá sobre pipelines de comando, um recurso poderoso no shell Linux que permite encadear vários comandos. A saída de um comando se torna a entrada do próximo, permitindo o processamento e a manipulação complexos de dados.

O operador pipe | (barra vertical) é usado para conectar comandos em um pipeline. Ele redireciona a saída padrão (stdout) do comando à sua esquerda para a entrada padrão (stdin) do comando à sua direita.

Pipelines Básicos

Vamos começar com um exemplo simples para entender como os pipelines funcionam.

Certifique-se de estar no seu diretório ~/project.
```
cd ~/project
```
```
[labex@host project]$
```

Primeiro, vamos listar os arquivos no diretório atual.

ls

combined_output.log
combined_output_shorthand.log
current_datetime.txt
errors.log
file_list.txt
line_count.txt

Agora, vamos canalizar a saída de ls para o comando wc -l, que conta o número de linhas que recebe.
```
ls | wc -l
```
```
6
```
O comando ls lista os arquivos, e sua saída (cada nome de arquivo em uma nova linha) é alimentada como entrada para wc -l, que então conta essas linhas, efetivamente informando quantos arquivos/diretórios estão no local atual.
Vamos tentar outro caso de uso comum: canalizar ls -l para less para saída paginada. Isso é útil quando um comando produz muita saída para caber em uma única tela.
```
ls -l /usr/bin | less
```
```
total 200000
-rwxr-xr-x 1 root root 12345 Jan XX HH:MM [filename]
... (press 'q' to quit less) ...
```
O comando ls -l /usr/bin lista todos os arquivos em /usr/bin com informações detalhadas. Essa saída é então enviada para less, permitindo que você role por ela página por página. Pressione q para sair de less.

Filtrando a Saída com `grep`

O comando grep é frequentemente usado em pipelines para filtrar linhas que correspondem a um padrão específico.

Vamos listar todos os processos em execução no sistema usando ps aux e, em seguida, filtrar os processos relacionados a bash.
```
ps aux | grep bash
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
labex     5678  0.0  0.0   9876  5432 pts/0    S+   HH:MM   0:00 grep bash
```
O comando ps aux lista todos os processos em execução. Sua saída é canalizada para grep bash, que então exibe apenas as linhas contendo a palavra "bash". Você pode ver duas linhas: uma para seu shell bash atual e outra para o próprio comando grep.
Para excluir o comando grep da saída, você pode usar grep -v (correspondência invertida) ou refinar seu padrão. Vamos tentar grep -v grep.
```
ps aux | grep bash | grep -v grep
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
```
Agora, apenas o processo bash real é mostrado.

Usando `sort` e `uniq`

sort é usado para classificar linhas de texto, e uniq é usado para relatar ou omitir linhas repetidas. Eles são frequentemente usados juntos.

Vamos criar um arquivo com algumas palavras não classificadas e repetidas.
```
echo -e "apple\nbanana\napple\norange\nbanana" > fruits.txt
```

Visualize o conteúdo de fruits.txt.

cat fruits.txt

apple
banana
apple
orange
banana

Agora, vamos classificar as linhas em fruits.txt.

cat fruits.txt | sort

apple
apple
banana
banana
orange

Para obter apenas as palavras classificadas exclusivas, canalize a saída de sort para uniq.
```
cat fruits.txt | sort | uniq
```
```
apple
banana
orange
```
Este pipeline primeiro classifica as linhas, então uniq remove linhas adjacentes duplicadas.

O Comando `tee`

O comando tee é especial em pipelines. Ele lê a entrada padrão, a escreve na saída padrão e, simultaneamente, a escreve em um ou mais arquivos. É como uma junção "T" em um pipe, permitindo que os dados fluam em duas direções.

Vamos listar os arquivos e salvar a saída em ls_output.txt enquanto também a exibimos na tela.

ls -l | tee ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output_shorthand.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM current_datetime.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM errors.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM file_list.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM fruits.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM line_count.txt
-rw-r--r-- 1 labex labex 0 Jan XX HH:MM ls_output.txt

Você verá a saída de ls -l no seu terminal, e um arquivo chamado ls_output.txt será criado com o mesmo conteúdo.

Verifique o conteúdo de ls_output.txt.

cat ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (same as above) ...

Você também pode usar tee -a para anexar a saída a um arquivo.
```
echo "--- End of list ---" | tee -a ls_output.txt
```
```
--- End of list ---
```
A linha "--- End of list ---" é impressa no terminal e anexada a ls_output.txt.

Verifique o ls_output.txt atualizado.

cat ls_output.txt

total 24
... (previous ls -l output) ...
--- End of list ---

Pipelines são incrivelmente versáteis e formam a espinha dorsal de muitos scripts de shell poderosos e comandos de uma linha. Ao combinar comandos simples, você pode realizar transformações complexas de dados de forma eficiente.

Editar Arquivos de Texto com Conceitos Básicos do Vim

Nesta etapa, você aprenderá as operações fundamentais do Vim, um editor de texto poderoso e amplamente utilizado no ambiente Linux. O Vim opera em diferentes modos, o que pode ser um pouco desafiador para iniciantes, mas dominar o básico aumentará significativamente sua produtividade.

Vim é um editor modal, o que significa que ele tem diferentes modos para diferentes tarefas:

Modo Normal (Modo de Comando): Este é o modo padrão quando você abre o Vim. Neste modo, as teclas são interpretadas como comandos (por exemplo, mover o cursor, excluir texto, copiar texto).
Modo Inserção: Neste modo, tudo o que você digita é inserido no arquivo. Você entra no Modo Inserção a partir do Modo Normal pressionando i (inserir no cursor), a (anexar após o cursor), o (abrir nova linha abaixo), etc. Para retornar ao Modo Normal, pressione Esc.
Modo Visual: Este modo permite que você selecione blocos de texto para operações como copiar, cortar ou excluir. Você entra no Modo Visual a partir do Modo Normal pressionando v (caractere por caractere), Shift+V (linha por linha) ou Ctrl+V (bloco por bloco). Pressione Esc para retornar ao Modo Normal.
Modo de Linha de Comando (Modo Ex): Este modo é usado para executar comandos que normalmente começam com dois pontos (:), como salvar (:w), sair (:q) ou pesquisar (/). Você entra neste modo a partir do Modo Normal pressionando :.

Abrindo e Navegação Básica

Certifique-se de estar no seu diretório ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Abra um novo arquivo chamado my_document.txt usando vim.
```
vim my_document.txt
```
Seu terminal agora exibirá a interface do Vim. Você está no Modo Normal.
No Modo Normal, você pode navegar usando as setas ou h (esquerda), j (baixo), k (cima), l (direita). Como o arquivo está vazio, não há muito para navegar ainda.

Modo Inserção: Adicionando Texto

Para começar a digitar, você precisa entrar no Modo Inserção. Pressione i (para inserir).
Você deve ver -- INSERT -- na parte inferior esquerda do seu terminal, indicando que você está no Modo Inserção.

Digite as seguintes linhas:

This is the first line.
This is the second line.
This is the third line.

Para sair do Modo Inserção e retornar ao Modo Normal, pressione a tecla Esc.
O indicador -- INSERT -- deve desaparecer.

Salvando e Saindo

No Modo Normal, para salvar o arquivo, digite :w e pressione Enter.
```
:w
```
Você deve ver my_document.txt [New] 3L, 60B written na parte inferior, confirmando o salvamento.
Para sair do Vim, digite :q e pressione Enter.
```
:q
```
Você será retornado ao seu prompt do shell.

Verifique o conteúdo de my_document.txt usando cat.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.

Editando Arquivos Existentes

Abra my_document.txt novamente.
```
vim my_document.txt
```
No Modo Normal, mova seu cursor para o início da segunda linha (usando j ou as setas).
Pressione Shift+V para entrar no Modo Visual de Linha. A linha inteira será destacada.
Pressione y para "yank" (copiar) a linha selecionada.
Mova seu cursor para o final da terceira linha (usando j ou as setas).
Pressione p para "put" (colar) a linha yanked abaixo da linha atual.
A segunda linha agora aparecerá novamente como a quarta linha.
Agora, vamos excluir uma linha. Mova seu cursor para a quarta linha (aquela que você acabou de colar).
Pressione dd (duplo d) para excluir a linha inteira.
Para desfazer sua última alteração, pressione u. A linha excluída reaparecerá.
Para salvar e sair em um comando, digite :wq e pressione Enter.
```
:wq
```
Verifique o conteúdo de my_document.txt novamente.
```
cat my_document.txt
```
```
This is the first line.
This is the second line.
This is the third line.
This is the second line.
```
O arquivo agora deve ter quatro linhas, com a segunda linha duplicada.

Descartando Alterações

Às vezes, você faz alterações e decide que não quer salvá-las.

Abra my_document.txt novamente.
```
vim my_document.txt
```
Entre no Modo Inserção pressionando i.
Adicione uma nova linha no final:
```
This line should not be saved.
```
Pressione Esc para retornar ao Modo Normal.
Tente sair usando :q.
```
:q
```
Vim irá avisá-lo: E37: No write since last change (add ! to override). Isso significa que você tem alterações não salvas.
Para sair sem salvar, digite :q! e pressione Enter.
```
:q!
```
Você será retornado ao prompt do shell, e suas alterações serão descartadas.

Verifique o conteúdo de my_document.txt.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.
This is the second line.

A última linha que você adicionou não deve estar presente.

Você agora cobriu as operações muito básicas no Vim: abrir arquivos, inserir texto, navegar, salvar, sair e descartar alterações. Essas são as habilidades essenciais para começar com o Vim.

Configurar e Usar Variáveis e Aliases do Shell

Nesta etapa, você aprenderá como configurar e usar variáveis e aliases do shell. Esses são recursos poderosos que permitem personalizar seu ambiente de shell, armazenar dados e criar atalhos para comandos usados com frequência, melhorando significativamente sua eficiência na linha de comando.

Variáveis do Shell

Variáveis do shell são entidades nomeadas que armazenam dados. Elas podem armazenar números, texto ou outros dados que podem ser usados pelo shell ou por programas executados dentro do shell.

Certifique-se de estar no seu diretório ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Definindo uma Variável Local: Vamos criar uma variável simples chamada MY_MESSAGE.
```
MY_MESSAGE="Hello, LabEx!"
```
Observe que não há espaços em volta do sinal =.
Acessando uma Variável: Para acessar o valor de uma variável, você precede seu nome com um sinal $.
```
echo $MY_MESSAGE
```
```
Hello, LabEx!
```
Expansão de Variável com Chaves: Às vezes, você precisa delimitar claramente o nome da variável, especialmente quando ele é seguido por outros caracteres. Use chaves {} para isso.
```
echo "The message is: ${MY_MESSAGE}."
```
```
The message is: Hello, LabEx!.
```
Se você omitir as chaves, o shell pode interpretar MY_MESSAGE. como o nome da variável, que não existe.
Listando Todas as Variáveis Definidas: Você pode usar o comando set para listar todas as variáveis e funções do shell atualmente definidas. Essa saída pode ser muito longa, por isso, geralmente, é canalizada para less.
```
set | less
```
```
BASH=/usr/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:progcomp:promptvars:sourcepath
... (press 'q' to quit less) ...
```
Pressione q para sair de less.
Desativando uma Variável: Para remover uma variável, use o comando unset.
```
unset MY_MESSAGE
```
Verifique se a variável não está mais definida.
```
echo $MY_MESSAGE
```
Você deve ver uma linha vazia, indicando que a variável foi desativada.

Variáveis de Ambiente

Variáveis de ambiente são um tipo especial de variável do shell que são herdadas por processos filhos. Isso significa que qualquer programa ou script lançado do seu shell atual terá acesso a essas variáveis. Elas são normalmente usadas para configurar o ambiente para aplicativos.

Definindo uma Variável de Ambiente: Use o comando export para tornar uma variável uma variável de ambiente.
```
export EDITOR=vim
```
Isso define a variável de ambiente EDITOR, que muitos programas usam para determinar seu editor de texto preferido.
Listando Variáveis de Ambiente: Use o comando env para listar apenas as variáveis de ambiente.
```
env | grep EDITOR
```
```
EDITOR=vim
```
Desexportando uma Variável: Você pode desexportar uma variável sem desativá-la usando export -n. Isso a torna uma variável local novamente.
```
export -n EDITOR
```
Verifique se ela não é mais uma variável de ambiente.
```
env | grep EDITOR
```
Você não deve ver nenhuma saída. No entanto, ela ainda é uma variável local:
```
echo $EDITOR
```
```
vim
```
Para removê-la completamente, use unset.
```
unset EDITOR
```

Aliases do Shell

Aliases são atalhos para comandos. Eles permitem que você defina um novo comando que se expande para um comando mais longo ou uma sequência de comandos. Isso é muito útil para comandos usados com frequência com muitas opções.

Criando um Alias: Vamos criar um alias para ls -l para torná-lo mais curto.
```
alias ll='ls -l'
```
Observe as aspas simples em volta do comando para garantir que ele seja tratado como uma única string.

Usando um Alias: Agora, você pode simplesmente digitar ll em vez de ls -l.

ll

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (output of ls -l) ...

Listando Aliases: Use o comando alias sem nenhum argumento para ver todos os aliases definidos.
```
alias
```
```
alias ll='ls -l'
```
Você pode ver outros aliases padrão, dependendo da configuração do seu shell.
Criando um Alias Mais Complexo: Você também pode criar aliases para comandos com argumentos ou vários comandos.
```
alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'
```
Aqui, myip mostrará seu endereço IP principal. Observe o \$2 para escapar do sinal $ para que ele seja passado para awk e não seja interpretado pelo shell quando o alias for definido.
Teste o alias myip.
```
myip
```
```
172.17.0.2
```
(Seu endereço IP pode variar)
Desativando um Alias: Para remover um alias, use o comando unalias.
```
unalias ll
```

Verifique se o alias foi removido.

alias

alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'

ll não deve mais estar na lista.

Variáveis e aliases do shell são temporários e serão perdidos quando você fechar sua sessão do terminal. Para torná-los permanentes, você precisa adicioná-los aos arquivos de configuração do seu shell (por exemplo, ~/.bashrc ou ~/.profile), o que será abordado em tópicos mais avançados.

Resumo

Neste laboratório, você aprendeu habilidades fundamentais da linha de comando Linux, essenciais para gerenciar arquivos de texto e o ambiente do shell. Você começou dominando o redirecionamento de saída, especificamente usando > para sobrescrever arquivos e >> para anexar conteúdo, permitindo que você capture os resultados dos comandos para registro ou processamento posterior. Você também explorou o redirecionamento do erro padrão (2>) e a combinação da saída padrão e do erro (&>) para gerenciar toda a saída do comando de forma eficaz.

Além disso, você adquiriu proficiência na construção e compreensão de pipelines de comandos usando o operador |, permitindo que você encadeie comandos e processe dados sequencialmente. Você foi apresentado à edição de texto básica com o Vim, cobrindo comandos essenciais para inserir, salvar e sair de arquivos. Por fim, você aprendeu a configurar e usar variáveis do shell para armazenar dados e criar aliases para simplificar comandos usados com frequência, aprimorando sua eficiência e personalização na linha de comando.

Editar Arquivos de Texto no Red Hat Enterprise Linux