Objetivos de Aprendizagem
Este exercício treina os nove comandos que você mais vai digitar na vida:
pwd, ls, mkdir, cd, touch,
cat, echo, rm e mv. Ao final, você será capaz de:
- Saber sempre onde está no sistema de arquivos e como chegar a qualquer outro lugar
- Ler e interpretar cada coluna da saída de
ls -l - Diferenciar caminho absoluto de caminho relativo e usar
.,..,~e- - Criar árvores de diretórios inteiras com um único
mkdir -p - Criar arquivos vazios e atualizar timestamps com
touch - Escrever conteúdo com
echousando>(sobrescreve) e>>(acrescenta) - Ler e concatenar arquivos com
cat - Renomear e mover arquivos e diretórios com
mv— e entender por que os dois são a mesma operação - Apagar arquivos e diretórios com
rmde forma consciente, sabendo o que não tem volta - Reconhecer as mensagens de erro mais comuns e corrigi-las sozinho
Antes de Começar
Ambiente necessário
- Acesso à sua VM Ubuntu via SSH ou terminal local
- Usuário comum (não precisa de
rootem nenhum passo) - Shell Bash — confirme com
echo $SHELL - Nada precisa ser instalado: os 9 comandos já vêm em qualquer Linux
Regras do jogo
- Digite os comandos — não copie e cole. A memória é muscular.
- Não use editores (
nano,vim): todo o conteúdo será escrito comecho - Antes de apertar Enter, leia o comando inteiro e tente prever a saída
- Se a saída for diferente do esperado, pare e descubra por quê antes de seguir
- Use Tab para autocompletar e ↑ para repetir comandos
Sobre o ambiente do laboratório:
todos os 33 passos rodam normalmente na sua VM Ubuntu, sem
sudo em nenhum
momento. Todo o trabalho acontece dentro do seu diretório pessoal ($HOME),
então nada aqui pode quebrar o sistema.
Aviso de segurança — leia antes do primeiro
rm:
o terminal não tem lixeira. O que rm apaga, some. Neste exercício
você só apagará arquivos que você mesmo criou, dentro de ~/estacao-ares.
Nunca execute rm -rf em um caminho que você não digitou por inteiro e conferiu.
Cronograma do Exercício
Mapa da Estrutura Final
Você vai assumir o papel de estagiário na Estação Meteorológica "Ares". Sua missão é montar, popular, reorganizar e limpar o diretório de trabalho da estação — usando apenas a linha de comando. Este é o destino final:
/home/aluno/estacao-ares/
├── config/
│ ├── estacao.conf
│ └── sensores.conf
├── dados/
│ ├── brutos/
│ │ ├── 2026-08-10.csv
│ │ ├── 2026-08-11.csv
│ │ ├── 2026-08-12.csv
│ │ └── 2026-08-13.csv
│ └── processados/
│ └── consolidado.csv
└── relatorios/
├── config-consolidada.txt
├── resumo-agosto.txt
└── resumo-julho.txt
Durante o caminho também existirá um diretório
temp/ com arquivos
de rascunho — ele será apagado na Parte F. Se ele ainda existir no final,
algum passo foi pulado.
Roteiro Passo a Passo
00:00 – 00:10
Parte A — Reconhecimento do terreno (passos 1 a 5)
10 min
Antes de construir qualquer coisa, um bom operador responde a duas perguntas:
onde eu estou? e o que existe aqui?. Os comandos
pwd e ls respondem exatamente isso, e você vai usá-los
centenas de vezes por dia pelo resto da sua carreira.
Passo 1 — Descubra onde você está (pwd)
pwd = print working directory
$ pwd /home/aluno
Ao abrir o terminal, o shell sempre te coloca no seu diretório pessoal (home). Esse é o único lugar do sistema onde você, como usuário comum, pode criar e apagar o que quiser. Guarde esse caminho: ele é o seu ponto de partida.
Passo 2 — Veja o que existe aqui (ls)
$ ls (possivelmente nada — um home recém-criado costuma estar vazio)
Silêncio não é erro. No Unix, “nenhuma saída” significa “deu certo e não há nada a dizer”. Um comando só fala quando tem resultado ou problema a relatar.
Passo 3 — Listagem longa: leia cada coluna (ls -l)
$ ls -l /etc/hostname -rw-r--r-- 1 root root 12 Aug 10 09:14 /etc/hostname # -rw-r--r-- 1 root root 12 Aug 10 09:14 /etc/hostname # │ │ │ │ │ │ │ # │ │ │ │ │ │ └── nome # │ │ │ │ │ └───────────────── data/hora da última modificação # │ │ │ │ └────────────────────────── tamanho em bytes # │ │ │ └───────────────────────────────── grupo dono # │ │ └─────────────────────────────────────── usuário dono # │ └──────────────────────────────────────────── nº de links # └───────────────────────────────────────────────────────── tipo + permissões
O primeiro caractere é o tipo:
- arquivo comum,
d diretório, l link simbólico. Você vai usar isso o tempo todo
para saber se algo é pasta ou arquivo sem precisar entrar nele.
Passo 4 — Arquivos ocultos e os diretórios . e .. (ls -a)
$ ls -a . .. .bash_logout .bashrc .profile $ ls -la total 20 drwxr-x--- 2 aluno aluno 4096 Aug 13 08:02 . drwxr-xr-x 3 root root 4096 Aug 10 09:14 .. -rw-r--r-- 1 aluno aluno 220 Aug 10 09:14 .bash_logout -rw-r--r-- 1 aluno aluno 3771 Aug 10 09:14 .bashrc -rw-r--r-- 1 aluno aluno 807 Aug 10 09:14 .profile
No Linux, qualquer nome que começa com ponto é oculto — não existe
“atributo escondido”, é só uma convenção do nome. E repare nas duas primeiras linhas:
. é o próprio diretório atual e .. é o diretório
pai. Eles existem em toda pasta do sistema e são a base da navegação relativa.
Passo 5 — Listar outro diretório sem sair do lugar
# ls aceita um caminho: você olha "lá" continuando "aqui" $ ls /etc | head -6 adduser.conf alternatives apt bash.bashrc bindresvport.blacklist ca-certificates # -h deixa os tamanhos legíveis para humanos (K, M, G) $ ls -lh /var/log | head -4 total 340K -rw-r--r-- 1 root root 32K Aug 13 08:00 alternatives.log drwxr-xr-x 2 root root 4.0K Aug 10 09:14 apt -rw-rw---- 1 root utmp 0 Aug 10 09:14 btmp # confirme: você continua no mesmo lugar de antes $ pwd /home/aluno
✔ Ponto de verificação A — responda sem olhar:
(1) qual é o caminho completo do seu home? (2) o que significa a letra
d
na primeira coluna do ls -l? (3) qual a diferença entre . e
..? (4) por que ls às vezes não imprime nada?
00:10 – 00:24
Parte B — Construindo a estrutura (passos 6 a 12)
14 min
Passo 6 — Crie o diretório do projeto (mkdir)
# Sempre confirme onde você está ANTES de criar algo $ pwd /home/aluno $ mkdir estacao-ares $ ls -l total 4 drwxr-xr-x 2 aluno aluno 4096 Aug 13 08:10 estacao-ares
Repare no
d inicial e no tamanho 4096: um diretório vazio
já ocupa um bloco do disco, porque ele é, na verdade, um arquivo especial que
guarda a lista de nomes que existem dentro dele.
Passo 7 — Entre no diretório (cd) e confirme
$ cd estacao-ares $ pwd /home/aluno/estacao-ares $ ls -a . .. # diretório recém-criado: só tem ele mesmo e o pai
cd não imprime nada quando funciona — por isso o par
cd + pwd é um hábito que vale ouro no começo.
Passo 8 — Crie vários diretórios de uma só vez
# mkdir aceita quantos nomes você quiser, separados por espaço $ mkdir dados relatorios config $ ls config dados relatorios
O
ls lista em ordem alfabética, não na ordem em que você
criou. Nomes de arquivos e diretórios no Linux são
sensíveis a maiúsculas: Dados e dados seriam
duas pastas diferentes. E evite espaços em nomes — use - ou _.
Passo 9 — Provoque um erro de propósito
# Tente criar uma pasta DENTRO de outra que ainda não existe $ mkdir temp/rascunho mkdir: cannot create directory 'temp/rascunho': No such file or directory
Erros no terminal são informação, não repreensão. Leia a mensagem devagar: ela diz
exatamente que o caminho intermediário (temp) não existe.
Aprender a ler mensagens de erro é metade do trabalho de um administrador.
Passo 10 — Resolva com mkdir -p (cria a árvore inteira)
# -p = "parents": cria todos os diretórios do caminho que faltarem $ mkdir -p temp/rascunho $ ls temp rascunho # O mesmo truque cria dois níveis de dados em UM comando $ mkdir -p dados/brutos dados/processados $ ls dados brutos processados # Bônus do -p: rodar de novo NÃO dá erro (útil em scripts) $ mkdir -p dados/brutos $ mkdir dados/brutos mkdir: cannot create directory 'dados/brutos': File exists
Passo 11 — Veja a árvore inteira (ls -R)
$ ls -R .: config dados relatorios temp ./config: ./dados: brutos processados ./dados/brutos: ./dados/processados: ./relatorios: ./temp: rascunho ./temp/rascunho:
-R significa recursivo: desce em todas as subpastas. Esse mesmo
-R vai reaparecer, muito mais perigoso, no rm -r da Parte F.
Passo 12 — Navegação: absoluto, relativo, .., ~ e -
Os cinco jeitos de se mover que você precisa dominar
# 1) Relativo: a partir de onde você está $ cd dados/brutos $ pwd /home/aluno/estacao-ares/dados/brutos # 2) .. sobe um nível; pode ser encadeado $ cd .. $ pwd /home/aluno/estacao-ares/dados $ cd ../.. $ pwd /home/aluno # 3) Absoluto: começa com / e funciona de qualquer lugar $ cd /home/aluno/estacao-ares/config $ pwd /home/aluno/estacao-ares/config # 4) ~ é um atalho para o seu home $ cd ~ $ pwd /home/aluno # 5) cd - volta para o diretório ANTERIOR (e imprime o destino) $ cd - /home/aluno/estacao-ares/config # cd sem nenhum argumento também volta para o home $ cd $ pwd /home/aluno # Volte para o projeto — todos os próximos passos partem daqui $ cd ~/estacao-ares $ pwd /home/aluno/estacao-ares
✔ Ponto de verificação B — sua árvore deve ter
config, dados/brutos, dados/processados,
relatorios e temp/rascunho. Confirme com ls -R.
Termine com pwd mostrando /home/aluno/estacao-ares.
00:24 – 00:36
Parte C — Criando arquivos vazios (passos 13 a 17)
12 min
Passo 13 — Crie arquivos com touch
# touch cria arquivos VAZIOS — vários de uma vez, como o mkdir $ touch config/estacao.conf config/sensores.conf $ ls config estacao.conf sensores.conf
Passo 14 — Confirme que estão realmente vazios
$ ls -l config total 0 -rw-r--r-- 1 aluno aluno 0 Aug 13 08:24 estacao.conf -rw-r--r-- 1 aluno aluno 0 Aug 13 08:24 sensores.conf
Tamanho 0 bytes e total 0: os arquivos existem, têm nome,
dono e permissões — mas nenhum conteúdo. No Linux, um arquivo vazio é perfeitamente
normal e muito usado como “marcador” ou placeholder.
Passo 15 — A outra função do touch: atualizar o horário
# Veja o horário atual do arquivo (com segundos) $ ls -l --time-style=+%H:%M:%S config/estacao.conf -rw-r--r-- 1 aluno aluno 0 08:24:11 config/estacao.conf # Espere 5 segundos e "toque" no arquivo de novo $ sleep 5 $ touch config/estacao.conf $ ls -l --time-style=+%H:%M:%S config/estacao.conf -rw-r--r-- 1 aluno aluno 0 08:24:16 config/estacao.conf
O nome faz sentido agora:
touch = “tocar”. Se o arquivo não
existe, ele é criado; se já existe, apenas a data de modificação é atualizada e o
conteúdo é preservado. Por isso touch nunca destrói dados —
ao contrário do > que você verá no passo 19.
Passo 16 — Crie os arquivos de leitura dos sensores
$ touch dados/brutos/2026-08-10.csv dados/brutos/2026-08-11.csv dados/brutos/2026-08-12.csv $ ls -l dados/brutos total 0 -rw-r--r-- 1 aluno aluno 0 Aug 13 08:26 2026-08-10.csv -rw-r--r-- 1 aluno aluno 0 Aug 13 08:26 2026-08-11.csv -rw-r--r-- 1 aluno aluno 0 Aug 13 08:26 2026-08-12.csv
Passo 17 — Crie o arquivo de hoje (no lugar errado, de propósito)
# Confirme que você está na RAIZ do projeto $ pwd /home/aluno/estacao-ares # Crie o CSV de hoje aqui mesmo — vamos consertar isso na Parte E $ touch 2026-08-13.csv $ ls 2026-08-13.csv config dados relatorios temp # O curinga * lista tudo que combina com o padrão, em qualquer subpasta $ ls dados/brutos/*.csv dados/brutos/2026-08-10.csv dados/brutos/2026-08-11.csv dados/brutos/2026-08-12.csv
✔ Ponto de verificação C — você deve ter 6 arquivos: 2 em
config/, 3 em dados/brutos/ e 1 solto na raiz do projeto.
Todos com 0 bytes. Confira com
ls -lR | grep -c '^-' (deve responder 6).
00:36 – 00:52
Parte D — Escrevendo e lendo conteúdo (passos 18 a 24)
16 min
Passo 18 — echo: o comando que só sabe falar
# echo imprime na tela o texto que você der a ele $ echo Estacao Ares Estacao Ares # Com aspas, os espaços múltiplos são preservados $ echo "Estacao Ares" Estacao Ares $ echo Estacao Ares Estacao Ares # sem aspas o shell colapsa os espaços # Aspas DUPLAS expandem variáveis; aspas SIMPLES não expandem nada $ echo "Usuario: $USER — Home: $HOME" Usuario: aluno — Home: /home/aluno $ echo 'Usuario: $USER' Usuario: $USER
Passo 19 — Redirecione a fala para dentro de um arquivo (>)
# > pega a saída do comando e joga DENTRO do arquivo, em vez da tela $ echo "nome=Estacao Ares" > config/estacao.conf # Nenhuma saída na tela — o texto foi para o arquivo $ ls -l config/estacao.conf -rw-r--r-- 1 aluno aluno 18 Aug 13 08:37 config/estacao.conf
O arquivo saiu de 0 para 18 bytes — os 17 caracteres do texto mais o
caractere de fim de linha (\n) que o echo
acrescenta automaticamente. Se o arquivo não existisse, > o
criaria; como já existia, o conteúdo anterior (vazio) foi descartado.
Passo 20 — Leia o arquivo (cat)
$ cat config/estacao.conf nome=Estacao Ares # cat em um arquivo que não existe: mais uma mensagem para aprender a ler $ cat config/inexistente.conf cat: config/inexistente.conf: No such file or directory
cat vem de concatenate. Ele foi criado para juntar
arquivos — mostrar um arquivo na tela é só o caso particular de “concatenar um
arquivo só”. Você usará a função original dele no passo 24.
Passo 21 — Acrescente linhas sem apagar as anteriores (>>)
# >> ACRESCENTA no final; > SOBRESCREVE tudo $ echo "cidade=Ji-Parana" >> config/estacao.conf $ echo "altitude=170" >> config/estacao.conf $ echo "fuso=America/Porto_Velho" >> config/estacao.conf $ cat config/estacao.conf nome=Estacao Ares cidade=Ji-Parana altitude=170 fuso=America/Porto_Velho # Agora popule o segundo arquivo de configuração $ echo "sensor01=temperatura" > config/sensores.conf $ echo "sensor02=umidade" >> config/sensores.conf $ echo "sensor03=pressao" >> config/sensores.conf $ cat config/sensores.conf sensor01=temperatura sensor02=umidade sensor03=pressao
Passo 22 — Popule um arquivo de dados e leia com número de linha
$ echo "hora,temp,umid" > dados/brutos/2026-08-10.csv $ echo "08:00,24.1,71" >> dados/brutos/2026-08-10.csv $ echo "12:00,31.7,52" >> dados/brutos/2026-08-10.csv $ echo "18:00,27.3,64" >> dados/brutos/2026-08-10.csv # -n numera as linhas — ótimo para conferir se não faltou nada $ cat -n dados/brutos/2026-08-10.csv 1 hora,temp,umid 2 08:00,24.1,71 3 12:00,31.7,52 4 18:00,27.3,64
Passo 23 — A armadilha do > (experimento controlado)
# Crie um rascunho descartável para o experimento $ echo "linha importante 1" > temp/rascunho/teste.txt $ echo "linha importante 2" >> temp/rascunho/teste.txt $ cat temp/rascunho/teste.txt linha importante 1 linha importante 2 # Agora use > por engano, achando que era >> $ echo "ops" > temp/rascunho/teste.txt $ cat temp/rascunho/teste.txt ops
As duas linhas anteriores foram destruídas — sem aviso, sem confirmação, sem
volta. Este é o erro nº 1 de quem está começando. Regra prática:
> só na primeira escrita de um arquivo; >>
em todas as seguintes. Na dúvida, use >>.
Passo 24 — cat na função original: juntar arquivos
# Vários arquivos de uma vez: a saída sai emendada, na ordem dada $ cat config/estacao.conf config/sensores.conf nome=Estacao Ares cidade=Ji-Parana altitude=170 fuso=America/Porto_Velho sensor01=temperatura sensor02=umidade sensor03=pressao # Junte os dois em UM arquivo novo dentro de relatorios/ $ cat config/estacao.conf config/sensores.conf > relatorios/config-completa.txt $ cat -n relatorios/config-completa.txt | tail -3 5 sensor01=temperatura 6 sensor02=umidade 7 sensor03=pressao # Dê conteúdo ao CSV do dia 11 e consolide os dois dias $ echo "hora,temp,umid" > dados/brutos/2026-08-11.csv $ echo "08:00,23.8,74" >> dados/brutos/2026-08-11.csv $ echo "12:00,32.4,49" >> dados/brutos/2026-08-11.csv $ cat dados/brutos/2026-08-10.csv dados/brutos/2026-08-11.csv > dados/processados/consolidado.csv $ cat dados/processados/consolidado.csv hora,temp,umid 08:00,24.1,71 12:00,31.7,52 18:00,27.3,64 hora,temp,umid 08:00,23.8,74 12:00,32.4,49
Repare que o cabeçalho
hora,temp,umid aparece duas vezes —
cat não é inteligente, ele apenas emenda bytes. Limpar isso é trabalho para
grep, head e tail, que você verá no próximo módulo.
✔ Ponto de verificação D — explique com suas palavras:
(1) a diferença entre
> e >>;
(2) por que echo 'valor: $USER' não mostra seu nome de usuário;
(3) o que cat a b > c faz exatamente.
00:52 – 01:06
Parte E — Reorganizando o projeto (passos 25 a 29)
14 min
A grande sacada do
mv: renomear e mover são
a mesma operação. Um arquivo é um nome dentro de um diretório; mudar o nome ou
mudar o diretório é sempre “apagar a entrada antiga e escrever uma nova”. Por isso o Linux
não precisa de um comando rename separado.
Passo 25 — Renomear um arquivo
# Sintaxe: mv ORIGEM DESTINO — mesmo diretório = renomear $ mv relatorios/config-completa.txt relatorios/config-consolidada.txt $ ls relatorios config-consolidada.txt
Passo 26 — Mover o arquivo que ficou no lugar errado
# Lembra do 2026-08-13.csv criado na raiz no passo 17? Hora de arrumar. $ ls 2026-08-13.csv config dados relatorios temp # Quando o DESTINO é um diretório existente, o arquivo entra nele com o mesmo nome $ mv 2026-08-13.csv dados/brutos/ $ ls config dados relatorios temp $ ls dados/brutos 2026-08-10.csv 2026-08-11.csv 2026-08-12.csv 2026-08-13.csv
A barra final em
dados/brutos/ não é obrigatória, mas é um
hábito excelente: ela deixa explícito “o destino é um diretório”. Sem a barra, se você
digitar o nome errado, o mv silenciosamente renomeia o arquivo em
vez de movê-lo.
Passo 27 — Mover vários arquivos de uma vez
# Crie dois resumos na raiz do projeto $ echo "Julho/2026: media 26.4 C, 12 dias de chuva" > resumo-julho.txt $ echo "Agosto/2026: media 28.9 C, 3 dias de chuva" > resumo-agosto.txt $ ls config dados relatorios resumo-agosto.txt resumo-julho.txt temp # Com vários arquivos, o ÚLTIMO argumento tem que ser um diretório $ mv resumo-julho.txt resumo-agosto.txt relatorios/ $ ls relatorios config-consolidada.txt resumo-agosto.txt resumo-julho.txt $ ls config dados relatorios temp
Passo 28 — Renomear um diretório inteiro
# mv funciona igual com diretórios — leva todo o conteúdo junto $ mv relatorios relatorios-2026 $ ls config dados relatorios-2026 temp $ ls relatorios-2026 config-consolidada.txt resumo-agosto.txt resumo-julho.txt # nada se perdeu # Desfaça: volte ao nome original (a operação é simétrica) $ mv relatorios-2026 relatorios $ ls config dados relatorios temp
Passo 29 — O perigo silencioso do mv
# Dois arquivos de teste, com conteúdos diferentes $ echo "SOU O ARQUIVO A" > temp/a.txt $ echo "SOU O ARQUIVO B" > temp/b.txt $ cat temp/a.txt temp/b.txt SOU O ARQUIVO A SOU O ARQUIVO B # mv sobre um arquivo EXISTENTE sobrescreve sem perguntar nada $ mv temp/a.txt temp/b.txt $ ls temp b.txt rascunho # a.txt sumiu... $ cat temp/b.txt SOU O ARQUIVO A # ...e o conteúdo de B foi destruído # As duas proteções que você deve adotar como hábito: $ echo "novo A" > temp/a.txt $ mv -i temp/a.txt temp/b.txt mv: overwrite 'temp/b.txt'? n # -i pergunta antes (responda n) $ mv -n temp/a.txt temp/b.txt $ ls temp a.txt b.txt rascunho # -n simplesmente não sobrescreve
✔ Ponto de verificação E — a raiz do projeto deve conter apenas
config, dados, relatorios e temp;
dados/brutos deve ter 4 CSVs e relatorios
3 arquivos .txt. Confirme com ls -R.
01:06 – 01:18
Parte F — Limpeza e faxina (passos 30 a 33)
12 min
Leia antes de digitar:
rm não manda para a lixeira.
Ele remove o nome do arquivo do diretório e o espaço volta para o sistema. Não existe
“desfazer”. Confira o caminho duas vezes antes do Enter — sempre.
Passo 30 — Apagar um arquivo (rm e rm -i)
# Material descartável para a faxina $ touch temp/a1.log temp/a2.log temp/a3.log $ ls temp a1.log a2.log a3.log a.txt b.txt rascunho # rm simples: apaga e cala a boca $ rm temp/a1.log $ ls temp a2.log a3.log a.txt b.txt rascunho # -i pergunta antes de cada arquivo (responda y) $ rm -i temp/a2.log rm: remove regular empty file 'temp/a2.log'? y # -v (verbose) mostra o que foi apagado — ótimo para auditoria $ rm -v temp/a3.log removed 'temp/a3.log'
Passo 31 — Apagar vários arquivos e o cuidado com o curinga
# Vários nomes de uma vez $ rm -v temp/a.txt temp/b.txt removed 'temp/a.txt' removed 'temp/b.txt' # REGRA DE OURO: antes de rm com curinga, teste o padrão com ls $ touch temp/x1.tmp temp/x2.tmp temp/manter.txt $ ls temp/*.tmp temp/x1.tmp temp/x2.tmp # confirmado: só o que eu quero apagar $ rm -v temp/*.tmp removed 'temp/x1.tmp' removed 'temp/x2.tmp' $ ls temp manter.txt rascunho # o arquivo que não casava com o padrão sobreviveu
Os três comandos que já destruíram sistemas inteiros:
rm -rf / (apaga a raiz), rm -rf * executado no diretório errado
(por isso pwd antes!) e rm -rf / home/aluno/x — um espaço a mais
depois da barra transforma o comando em “apague a raiz e a pasta x”.
Passo 32 — Diretórios: rmdir vs. rm -r
# rm comum se recusa a apagar diretórios — é uma proteção $ rm temp rm: cannot remove 'temp': Is a directory # rmdir só funciona em diretório VAZIO — é a forma mais segura $ rmdir temp/rascunho rmdir: failed to remove 'temp/rascunho': Directory not empty # Por quê? O teste.txt do passo 23 ainda está lá dentro $ ls temp/rascunho teste.txt $ rm temp/rascunho/teste.txt $ rmdir temp/rascunho # agora sim: o diretório está vazio $ ls temp manter.txt # Em diretório com conteúdo, rmdir se recusa (e ainda bem) $ rmdir temp rmdir: failed to remove 'temp': Directory not empty $ rmdir dados rmdir: failed to remove 'dados': Directory not empty # seus dados estão a salvo
Passo 33 — A faxina final com rm -r
# SEMPRE confira onde você está e o que vai apagar $ pwd /home/aluno/estacao-ares $ ls -R temp temp: manter.txt # -r = recursivo: apaga o diretório e TUDO que há dentro dele $ rm -rv temp removed 'temp/manter.txt' removed directory 'temp' $ ls config dados relatorios # temp/ não existe mais
✔ Ponto de verificação F — explique a diferença entre
rmdir, rm -r e rm -rf, e diga qual comando você
digitaria antes de qualquer rm com curinga.
Conferência Final
Rode os três comandos abaixo e compare com a saída esperada:
$ cd ~/estacao-ares $ pwd /home/aluno/estacao-ares $ ls -R .: config dados relatorios ./config: estacao.conf sensores.conf ./dados: brutos processados ./dados/brutos: 2026-08-10.csv 2026-08-11.csv 2026-08-12.csv 2026-08-13.csv ./dados/processados: consolidado.csv ./relatorios: config-consolidada.txt resumo-agosto.txt resumo-julho.txt # Contagem rápida: 3 diretórios na raiz e 10 arquivos no total $ ls -lR | grep -c '^-' 10
Autoavaliação — marque o que você concluiu
- Sei dizer, a qualquer momento, em que diretório estou e como voltar ao home de três formas diferentes
- Leio a saída de
ls -le identifico tipo, dono, tamanho e data - Criei uma árvore de dois níveis com um único
mkdir -p - Sei a diferença entre caminho absoluto (
/home/aluno/...) e relativo (dados/brutos) - Usei
touchtanto para criar quanto para atualizar o horário de um arquivo - Escrevi um arquivo de configuração inteiro usando só
echocom>e>> - Perdi conteúdo de propósito com
>e entendi exatamente por quê - Concatenei dois arquivos em um terceiro com
cat a b > c - Renomeei e movi arquivos e um diretório inteiro com
mv - Vi o
mvsobrescrever um arquivo sem avisar e conheço-ie-n - Testei o curinga com
lsantes de usá-lo comrm - Sei quando usar
rmdire quando usarrm -r - A estrutura final bate exatamente com a saída de
ls -Racima
Desafio Individual
⚡ Desafio — "Reconstrução às Cegas"
Duração: 20 minutos |
Formato: Individual, sem consultar o roteiro acima |
Entregável: ~/desafio01/prova.txt
Missão
A estação foi replicada em outra cidade. Monte a estrutura abaixo em
~/desafio01 usando apenas os nove comandos deste exercício
(pwd, ls, mkdir, cd, touch,
cat, echo, rm, mv) e os
redirecionamentos > e >>. Nada de editores de texto.
~/desafio01/ ├── entrada/ │ └── bruto.csv (3 linhas: cabeçalho + 2 leituras) ├── saida/ │ └── final.csv (cópia do bruto.csv, obtida com cat + >) ├── docs/ │ └── LEIA-ME.txt (4 linhas: seu nome, data, cidade e objetivo) └── prova.txt (gerado no último passo)
Regras adicionais
- Crie
entrada,saidaedocscom um únicomkdir - O arquivo
bruto.csvdeve nascer em~/desafio01(raiz) e chegar aentrada/viamv - Crie um diretório
rascunho/com pelo menos 2 arquivos dentro e apague-o por completo antes do final - Use
echocom aspas duplas para incluir a data via$(date +%F)noLEIA-ME.txt - Nenhum arquivo pode ficar com 0 bytes ao final (confira com
ls -lR)
Passo final — gerar a prova
$ cd ~/desafio01 $ echo "Aluno: SEU NOME AQUI" > prova.txt $ echo "Data: $(date '+%Y-%m-%d %H:%M')" >> prova.txt $ echo "Diretorio: $(pwd)" >> prova.txt $ echo "--- estrutura ---" >> prova.txt $ ls -lR >> prova.txt $ echo "--- conteudos ---" >> prova.txt $ cat entrada/bruto.csv saida/final.csv docs/LEIA-ME.txt >> prova.txt # Confira o resultado antes de entregar $ cat prova.txt
Bônus (opcional)
- Faça a estrutura inteira sem nunca usar
cd— só com caminhos relativos e absolutos - Descubra, com
ls -l, quantos bytes tem cada arquivo e explique de onde vem cada byte (dica: o\nfinal conta) - Refaça o desafio do zero em menos de 5 minutos, apagando tudo antes com um único
rm -r ~/desafio01
Erros Comuns e Como Sair Deles
Referência Rápida dos 9 Comandos
pwd — onde estou
pwd → caminho atual completo
ls — o que existe
ls → nomes ls -l → detalhes (tipo, dono, tamanho) ls -a → inclui ocultos (.arquivo) ls -lh → tamanhos legíveis (K, M, G) ls -R → desce nas subpastas ls DIR → lista sem entrar
cd — mudar de lugar
cd dir → entra (relativo) cd /a/b → caminho absoluto cd .. → sobe um nível cd ~ ou cd → vai para o home cd - → volta ao anterior
mkdir — criar pastas
mkdir a → uma pasta mkdir a b c → várias mkdir -p a/b/c → árvore inteira mkdir -p → não reclama se existir
touch — criar / tocar
touch f → cria vazio touch f1 f2 f3 → vários touch f (existe) → só atualiza a data
echo — falar / escrever
echo texto → imprime na tela echo "$USER" → expande variável echo 'x' → literal, sem expansão echo x > f → cria/SOBRESCREVE echo x >> f → ACRESCENTA no fim
cat — ler / juntar
cat f → mostra o conteúdo cat -n f → numera as linhas cat a b → emenda na tela cat a b > c → emenda em arquivo
mv — mover / renomear
mv a b → renomeia mv a dir/ → move mv a b c dir/ → move vários mv -i → pergunta antes mv -n → nunca sobrescreve
rm — apagar (sem volta)
rm f → apaga arquivo rm -i f → pergunta antes rm -v f → mostra o que apagou rm -r dir → apaga pasta e conteúdo rmdir dir → só se estiver vazia
Checklist de Avaliação
Pontuação Sugerida
Iniciante — 0 a 5 pts
Completa os 33 passos seguindo o roteiro, mas se perde ao navegar sem consultar; não conclui o desafio sem ajuda.
Intermediário — 6 a 8 pts
Estrutura final correta, conclui o desafio consultando pouco, sabe explicar
> vs. >> e rmdir vs. rm -r.
Avançado — 9 a 10 pts
Conclui o desafio e o bônus, prevê a saída dos comandos antes de rodar e corrige qualquer erro lendo apenas a mensagem do terminal.
Entrega
O que enviar
- O conteúdo de
~/desafio01/prova.txt(copie e cole no formulário da disciplina) - A saída de
ls -R ~/estacao-aresmostrando a estrutura final do roteiro - Uma resposta em 3 linhas: qual passo foi o mais difícil e por quê
Comando único que gera tudo o que deve ser entregue
$ echo "=== ENTREGA — Exercicio 01 — SEU NOME ===" > ~/entrega01.txt $ echo "Data: $(date '+%F %H:%M')" >> ~/entrega01.txt $ echo "--- estacao-ares ---" >> ~/entrega01.txt $ ls -R ~/estacao-ares >> ~/entrega01.txt $ echo "--- desafio01 ---" >> ~/entrega01.txt $ cat ~/desafio01/prova.txt >> ~/entrega01.txt $ cat ~/entrega01.txt
Recursos e Referências
LPI (referência principal)
Documentação no próprio sistema
- 📖
man ls·man mv·man rm - 📖
ls --help— resumo rápido das opções - 📖
help cd·help pwd(são builtins do Bash, não têmmanpróprio)
Orientações Gerais
Como aproveitar melhor este exercício
- Preveja antes de rodar. Diga em voz alta o que espera ver e só então aperte Enter — o aprendizado acontece na diferença entre a previsão e o resultado
- Use Tab obsessivamente: além de poupar digitação, ele prova que o caminho existe
- Rode
pwdsempre que sentir a menor dúvida — é gratuito e evita 90% dos acidentes - Quando um comando falhar, leia a mensagem inteira antes de tentar outra coisa
- Refaça o roteiro do zero (apague
~/estacao-arescomrm -r) até conseguir sem olhar; a autonomia é o objetivo real - Anote os comandos que você errou — eles são o seu material de estudo personalizado
Erros conceituais a evitar
- Achar que “nenhuma saída” é erro — no Unix, silêncio é sinal de sucesso
- Confundir
/(raiz do sistema) com~(seu home) - Usar
>quando queria>>— a causa nº 1 de conteúdo perdido - Digitar
rmcom curinga sem antes testar o padrão comls - Colocar espaços em nomes de arquivos: tecnicamente permitido, praticamente uma dor de cabeça
- Esquecer que nomes são sensíveis a maiúsculas:
Dados≠dados