Exercício Prático 03 — Cópias, Backup e Restauração

Objetivos de Aprendizagem

Este exercício reúne tudo do Exercício 01 — pwd, ls, mkdir, cd, touch, cat, echo, rm e mv — e acrescenta o décimo comando, aquele que separa quem "mexe no Linux" de quem administra Linux: o cp, para arquivos e para diretórios inteiros. O roteiro termina com o exercício mais importante da carreira de qualquer administrador: apagar algo por engano e restaurar a partir do backup. Ao final, você será capaz de:

Copiar arquivos com cp, renomeando no mesmo comando ou mantendo o nome
Copiar vários arquivos de uma vez e usar curingas com segurança
Copiar diretórios inteiros com cp -r e prever exatamente onde a cópia vai parar
Explicar a diferença entre cp -r origem destino quando o destino existe e quando não existe
Copiar apenas o conteúdo de um diretório com origem/.
Usar -i, -n, -v, -p e -u e saber quando cada um salva o seu dia
Diferenciar cp de mv na prática — e saber por que mv não precisa de -r
Criar árvores de pasta/subpasta com mkdir -p e povoá-las com touch e echo
Apagar com rm de forma consciente e restaurar um diretório perdido a partir do backup
Resolver sozinho as mensagens de erro típicas do cp

Antes de Começar

Ambiente necessário

Acesso à sua VM Ubuntu via SSH ou terminal local
Usuário comum (nenhum passo precisa de root)
Shell Bash — confirme com echo $SHELL
Nada a instalar: os 10 comandos existem em qualquer Linux
Pré-requisito: Exercício 01 (e, de preferência, o 02)

Regras do jogo

Digite os comandos — não copie e cole. A memória é muscular.
Nada de editores (nano, vim): todo conteúdo vem de echo
Antes do Enter, diga em voz alta onde a cópia vai parar
Depois de todo cp, confirme com ls — sempre
Tab autocompleta e ↑ repete o comando anterior

Sobre o ambiente do laboratório: todos os 38 passos rodam normalmente na sua VM Ubuntu, sem sudo em nenhum momento. Tudo acontece dentro do seu $HOME. As saídas mostradas foram conferidas no GNU coreutils 9.x; em versões mais antigas o texto de uma ou outra mensagem pode mudar levemente — o sentido é sempre o mesmo.

Por que este exercício tem um "acidente" no meio: nos passos 36 e 37 você vai apagar de propósito um diretório inteiro e depois restaurá-lo a partir do backup criado no passo 22. Não pule essa dupla: ela é o exercício mais realista de toda a disciplina. Backup só existe de verdade quando a restauração é testada.

Cronograma do Exercício

Horário	Parte	Passos	Comandos em foco	Duração
00:00 – 00:12	A — Preparando a bancada	1 – 6	`pwd`, `mkdir -p`, `cd`, `ls`	12 min
00:12 – 00:26	B — Os arquivos-modelo	7 – 12	`touch`, `echo`, `cat`	14 min
00:26 – 00:50	C — `cp` com arquivos	13 – 20	`cp`, `cp -v -i -n -p`	24 min
00:50 – 01:14	D — `cp -r` com diretórios	21 – 27	`cp -r`, `-a`, `-u`	24 min
01:14 – 01:30	E — `cp` × `mv`	28 – 32	`mv`, `cp`	16 min
01:30 – 01:48	F — Acidente e restauração	33 – 38	`rm`, `rmdir`, `cp -r`	18 min
01:48 – 01:55	Conferência final	—	`ls -R`	7 min
01:55 – 02:00	Mini-desafios + desafio individual	—	todos os 10	5 min (+ casa)

Mapa da Estrutura Final

Você é o técnico responsável pelo Laboratório de Informática "Bit Livre". O laboratório tem três máquinas e cada uma precisa da sua ficha de inventário e do seu arquivo de rede. Em vez de digitar tudo três vezes, você vai criar arquivos-modelo e copiá-los — que é exatamente como isso é feito no mundo real. Depois vai fazer o backup, sofrer um acidente e restaurar. Este é o destino final:

/home/aluno/laboratorio/
├── backup/
│   └── maquinas/
│       ├── lab01/
│       │   ├── inventario.txt
│       │   └── rede.conf
│       ├── lab02/
│       │   ├── inventario.txt
│       │   └── rede.conf
│       └── lab03/
│           ├── inventario.txt
│           └── rede.conf
├── maquinas/
│   ├── lab01/
│   │   ├── inventario.txt
│   │   └── rede.conf
│   ├── lab02/
│   │   ├── inventario.txt
│   │   └── rede.conf
│   └── lab03/
│       ├── inventario.txt
│       └── rede.conf
└── modelos/
    ├── inventario-modelo.txt
    └── rede-modelo.conf

No meio do caminho existirão um diretório descartes/ (bancada de testes) e um maquinas/lab04/ criado por engano — os dois serão apagados na Parte F. Ao final devem restar 3 diretórios na raiz e 14 arquivos no total, sendo o conteúdo de backup/maquinas idêntico ao de maquinas.

Roteiro Passo a Passo

00:00 – 00:12 Parte A — Preparando a bancada (passos 1 a 6) 12 min

Aqui você repete o que já sabe do Exercício 01, mas com uma exigência a mais: montar pasta e subpasta em um único comando e conferir cada nível antes de seguir. Uma árvore malfeita no começo estraga todos os cp do meio do exercício.

Passo 1 — Ponto de partida (`cd`, `pwd`, `ls`)

# Garanta que você começa no seu home, não importa onde estivesse
$ cd
$ pwd
/home/aluno

$ ls -F
estacao-ares/  radio-onda-livre/   # o que sobrou dos exercícios 01 e 02

Passo 2 — Pasta e subpasta em um comando só (`mkdir -p`)

# -p cria TODOS os níveis do caminho de uma vez: 3 diretórios em 1 comando
$ mkdir -p laboratorio/maquinas/lab01

$ ls -R laboratorio
laboratorio:
maquinas

laboratorio/maquinas:
lab01

laboratorio/maquinas/lab01:

Sem o -p, esse mesmo resultado exigiria três comandos, na ordem certa: mkdir laboratorio, mkdir laboratorio/maquinas e mkdir laboratorio/maquinas/lab01. O -p ("parents") faz os três e ainda não reclama se algum já existir.

Passo 3 — Entre e crie os diretórios do primeiro nível

$ cd laboratorio
$ pwd
/home/aluno/laboratorio

# Três pastas irmãs, um comando
$ mkdir modelos backup descartes
$ ls -F
backup/  descartes/  maquinas/  modelos/

Passo 4 — Mais subpastas, agora com `-pv`

# -v (verbose) mostra exatamente o que foi criado
$ mkdir -pv maquinas/lab02 maquinas/lab03
mkdir: created directory 'maquinas/lab02'
mkdir: created directory 'maquinas/lab03'

Repare no que não apareceu: o mkdir não anunciou maquinas, porque essa pasta já existia desde o passo 2. Rodar de novo não muda nada e não dá erro — essa propriedade se chama idempotência e é o que torna o -p seguro dentro de scripts.

Passo 5 — Provoque um erro de propósito (e conserte)

# Criar subpasta dentro de uma pasta que ainda não existe
$ mkdir maquinas/lab04/turno-manha
mkdir: cannot create directory 'maquinas/lab04/turno-manha': No such file or directory

# A mensagem diz tudo: falta o nível intermediário (lab04)
$ mkdir -p maquinas/lab04/turno-manha
$ ls -R maquinas/lab04
maquinas/lab04:
turno-manha

maquinas/lab04/turno-manha:

Guarde esse lab04: ele foi criado por engano (o laboratório só tem três máquinas) e será removido na Parte F. Erro cometido, erro corrigido — é assim que se trabalha.

Passo 6 — Confira a árvore e treine a navegação

$ ls -R
.:
backup  descartes  maquinas  modelos

./backup:

./descartes:

./maquinas:
lab01  lab02  lab03  lab04

./maquinas/lab01:

./maquinas/lab02:

./maquinas/lab03:

./maquinas/lab04:
turno-manha

./maquinas/lab04/turno-manha:

./modelos:

# Relativo, .. encadeado, absoluto, ~ e o atalho cd -
$ cd maquinas/lab01
$ pwd
/home/aluno/laboratorio/maquinas/lab01

$ cd ../..
$ pwd
/home/aluno/laboratorio

$ cd /home/aluno/laboratorio/modelos
$ cd -
/home/aluno/laboratorio

# TODOS os próximos passos partem daqui — confirme antes de seguir
$ cd ~/laboratorio
$ pwd
/home/aluno/laboratorio

✔ Ponto de verificação A — você deve ter 4 diretórios na raiz (backup, descartes, maquinas, modelos) e 4 subpastas em maquinas. Nenhum arquivo ainda — ls -lR | grep -c '^-' deve responder 0.

00:12 – 00:26 Parte B — Os arquivos-modelo (passos 7 a 12) 14 min

A ideia central desta parte: escrever uma vez, copiar três. Você vai criar dois arquivos-modelo caprichados e, na Parte C, eles viram as fichas das três máquinas sem você digitar uma linha a mais.

Passo 7 — Crie os dois modelos vazios (`touch`)

$ touch modelos/inventario-modelo.txt modelos/rede-modelo.conf
$ ls -l modelos
total 0
-rw-r--r-- 1 aluno aluno 0 Sep  8 09:12 inventario-modelo.txt
-rw-r--r-- 1 aluno aluno 0 Sep  8 09:12 rede-modelo.conf

total 0 e 0 bytes: os arquivos existem, têm nome, dono, permissão e data — só não têm conteúdo. Vamos resolver isso agora.

Passo 8 — Preencha o inventário-modelo (`>` uma vez, `>>` o resto)

# A PRIMEIRA linha com > (cria/zera). Todas as outras com >> (acrescenta).
$ echo "maquina=MODELO" > modelos/inventario-modelo.txt
$ echo "processador=i5" >> modelos/inventario-modelo.txt
$ echo "memoria=8G" >> modelos/inventario-modelo.txt
$ echo "disco=256G" >> modelos/inventario-modelo.txt

$ cat modelos/inventario-modelo.txt
maquina=MODELO
processador=i5
memoria=8G
disco=256G

Passo 9 — Preencha o modelo de rede e leia numerado (`cat -n`)

$ echo "ip=192.168.0.X" > modelos/rede-modelo.conf
$ echo "mascara=255.255.255.0" >> modelos/rede-modelo.conf
$ echo "gateway=192.168.0.1" >> modelos/rede-modelo.conf

$ cat -n modelos/rede-modelo.conf
     1  ip=192.168.0.X
     2  mascara=255.255.255.0
     3  gateway=192.168.0.1

O X no lugar do último número do IP é um marcador: todo modelo tem um campo que só o destino sabe preencher. Você vai substituí-lo em cada máquina no passo 21.

Passo 10 — Confirme os tamanhos (`ls -l`)

$ ls -l modelos
total 8
-rw-r--r-- 1 aluno aluno 52 Sep  8 09:15 inventario-modelo.txt
-rw-r--r-- 1 aluno aluno 57 Sep  8 09:15 rede-modelo.conf

Os 52 bytes são a soma exata dos caracteres das 4 linhas mais 4 quebras de linha — o echo acrescenta um \n ao final de cada uma. Guarde esses dois números: no passo 18 eles vão provar que a cópia saiu idêntica ao original.

Passo 11 — Aspas simples × aspas duplas (revisão rápida)

# Aspas DUPLAS expandem variáveis e $(comandos)
$ echo "Tecnico: $USER — Lab: $HOME/laboratorio"
Tecnico: aluno — Lab: /home/aluno/laboratorio

# Aspas SIMPLES são literais: nada é interpretado
$ echo 'Tecnico: $USER'
Tecnico: $USER

# -e interpreta \t (tabulação) e \n (nova linha): útil para tabelas
$ echo -e "maquina\tip\nlab01\t192.168.0.11"
maquina	ip
lab01	192.168.0.11

Passo 12 — A armadilha do `>` (experimento na bancada de testes)

$ echo "anotacao importante 1" > descartes/bloco.txt
$ echo "anotacao importante 2" >> descartes/bloco.txt
$ cat descartes/bloco.txt
anotacao importante 1
anotacao importante 2

# Agora use > achando que era >>
$ echo "ops" > descartes/bloco.txt
$ cat descartes/bloco.txt
ops

As duas linhas anteriores foram destruídas — sem aviso e sem volta. Repita esta regra até virar reflexo: > só na primeira escrita de um arquivo, >> em todas as seguintes. Na dúvida, >>.

✔ Ponto de verificação B — modelos/ deve ter 2 arquivos com 52 e 57 bytes, e descartes/ 1 arquivo. Confira com ls -lR | grep -c '^-' (deve responder 3).

00:26 – 00:50 Parte C — cp com arquivos (passos 13 a 20) 24 min

A sintaxe do cp é a mesma do mv: cp ORIGEM DESTINO. A diferença é o que sobra no final: cp deixa dois arquivos, mv deixa um. Tudo o que você já sabe sobre destinos do mv — arquivo novo, diretório existente, vários de uma vez — vale igualzinho aqui.

Passo 13 — A primeira cópia: copiar e renomear no mesmo comando

# ORIGEM = o modelo | DESTINO = um nome de arquivo que ainda não existe
$ cp modelos/inventario-modelo.txt maquinas/lab01/inventario.txt

# Prova nº 1: a ORIGEM continua intacta (aqui está a diferença para o mv)
$ ls modelos
inventario-modelo.txt  rede-modelo.conf

# Prova nº 2: o DESTINO existe, com o nome novo
$ ls maquinas/lab01
inventario.txt

# Prova nº 3: o conteúdo é idêntico
$ cat maquinas/lab01/inventario.txt
maquina=MODELO
processador=i5
memoria=8G
disco=256G

Copiar e renomear em um único comando é o uso mais comum do cp no dia a dia: é assim que se cria um arquivo de configuração novo a partir de um modelo, sem nunca tocar no modelo.

Passo 14 — Destino arquivo × destino diretório

# (a) Destino é um NOME DE ARQUIVO → a cópia nasce com esse nome
$ cp -v modelos/rede-modelo.conf maquinas/lab01/rede.conf
'modelos/rede-modelo.conf' -> 'maquinas/lab01/rede.conf'

# (b) Destino é um DIRETÓRIO existente → a cópia mantém o nome original
$ cp -v modelos/rede-modelo.conf descartes/
'modelos/rede-modelo.conf' -> 'descartes/rede-modelo.conf'

$ ls maquinas/lab01 descartes
descartes:
bloco.txt  rede-modelo.conf

maquinas/lab01:
inventario.txt  rede.conf

O -v deveria ser obrigatório na sua vida. Ele imprime origem -> destino e responde de graça a pergunta que mais causa confusão com cp: "onde exatamente essa cópia foi parar?". Adote como hábito.

Passo 15 — Vários arquivos de uma vez (o último argumento é o destino)

# Com vários arquivos, o ÚLTIMO argumento TEM que ser um diretório
$ cp -v modelos/inventario-modelo.txt modelos/rede-modelo.conf maquinas/lab02/
'modelos/inventario-modelo.txt' -> 'maquinas/lab02/inventario-modelo.txt'
'modelos/rede-modelo.conf' -> 'maquinas/lab02/rede-modelo.conf'

# Repare: os nomes vieram do MODELO. Padronize com mv (que você já domina)
$ mv maquinas/lab02/inventario-modelo.txt maquinas/lab02/inventario.txt
$ mv maquinas/lab02/rede-modelo.conf maquinas/lab02/rede.conf
$ ls maquinas/lab02
inventario.txt  rede.conf

# E se o último argumento NÃO for um diretório? Erro — leia com atenção
$ cp modelos/inventario-modelo.txt modelos/rede-modelo.conf descartes/bloco.txt
cp: target 'descartes/bloco.txt': Not a directory

cp + mv trabalham juntos o tempo todo: cp traz o arquivo, mv ajusta o nome. Alternativa em um passo só: copiar já com o nome final, como no passo 13 — duas cópias, dois cp. Escolha o caminho que você conseguir explicar.

Passo 16 — Curinga com `cp`: teste com `ls` antes

# REGRA DE OURO: veja o que o padrão casa ANTES de usá-lo em um comando
$ ls modelos/*
modelos/inventario-modelo.txt  modelos/rede-modelo.conf

# Confirmado o alvo, agora sim
$ cp -v modelos/* descartes/
'modelos/inventario-modelo.txt' -> 'descartes/inventario-modelo.txt'
'modelos/rede-modelo.conf' -> 'descartes/rede-modelo.conf'

# Curinga por extensão: só os .conf
$ ls descartes/*.conf
descartes/rede-modelo.conf

$ ls descartes
bloco.txt  inventario-modelo.txt  rede-modelo.conf

Passo 17 — `cp` sobrescreve sem avisar: `-i` e `-n`

# Dois arquivos com conteúdos diferentes, na bancada de testes
$ echo "SOU O ORIGINAL" > descartes/alvo.txt
$ echo "SOU O INVASOR" > descartes/fonte.txt

# cp puro e simples: destrói o destino sem perguntar nada
$ cp descartes/fonte.txt descartes/alvo.txt
$ cat descartes/alvo.txt
SOU O INVASOR   # "SOU O ORIGINAL" não existe mais

# -i pergunta antes de sobrescrever (responda n para cancelar)
$ echo "SOU O ORIGINAL DE NOVO" > descartes/alvo.txt
$ cp -i descartes/fonte.txt descartes/alvo.txt
cp: overwrite 'descartes/alvo.txt'? n

$ cat descartes/alvo.txt
SOU O ORIGINAL DE NOVO   # o "n" salvou o arquivo

# -n nunca sobrescreve, sem perguntar nada
$ cp -n descartes/fonte.txt descartes/alvo.txt
$ cat descartes/alvo.txt
SOU O ORIGINAL DE NOVO

Em versões recentes do coreutils, o -n pode imprimir um aviso:

cp: warning: behavior of -n is non-portable and may change in future; use
        --update=none instead

. É só um aviso — o arquivo foi preservado do mesmo jeito. A forma moderna e recomendada é cp --update=none origem destino.

Passo 18 — `-p`: a cópia que preserva data e permissões

# Veja a hora do modelo (com segundos)
$ ls -l --time-style=+%H:%M:%S modelos/rede-modelo.conf
-rw-r--r-- 1 aluno aluno 57 09:15:02 modelos/rede-modelo.conf

# Espere e faça duas cópias: uma sem -p e outra com -p
$ sleep 5
$ cp modelos/rede-modelo.conf descartes/sem-p.conf
$ cp -p modelos/rede-modelo.conf descartes/com-p.conf

$ ls -l --time-style=+%H:%M:%S descartes/sem-p.conf descartes/com-p.conf
-rw-r--r-- 1 aluno aluno 57 09:15:02 descartes/com-p.conf
-rw-r--r-- 1 aluno aluno 57 09:26:40 descartes/sem-p.conf

A cópia comum nasce com a hora de agora — para o sistema, ela é um arquivo novinho. Com -p ("preserve"), a cópia carrega a data, o modo e o dono do original. Em backup isso importa muito: sem -p, você perde a informação de quando cada arquivo foi modificado pela última vez. E note que os dois têm 57 bytes — o conteúdo é sempre idêntico.

Passo 19 — As três mensagens de erro do `cp` que você vai encontrar

# (a) A origem não existe
$ cp modelos/inexistente.txt descartes/
cp: cannot stat 'modelos/inexistente.txt': No such file or directory

# (b) A origem é um DIRETÓRIO e faltou o -r
$ cp maquinas/lab01 descartes/
cp: -r not specified; omitting directory 'maquinas/lab01'

# (c) Origem e destino são o MESMO arquivo
$ cp descartes/alvo.txt descartes/alvo.txt
cp: 'descartes/alvo.txt' and 'descartes/alvo.txt' are the same file

"stat" é a chamada de sistema que pergunta ao kernel "me fale sobre este arquivo". cannot stat quase sempre significa caminho errado ou nome digitado errado — antes de qualquer outra hipótese, rode ls no diretório pai e use Tab.

Passo 20 — Clonando a configuração de uma máquina para outra

# A lab03 recebe cópias dos arquivos JÁ configurados da lab01
$ cp -v maquinas/lab01/inventario.txt maquinas/lab01/rede.conf maquinas/lab03/
'maquinas/lab01/inventario.txt' -> 'maquinas/lab03/inventario.txt'
'maquinas/lab01/rede.conf' -> 'maquinas/lab03/rede.conf'

# As três máquinas já têm os dois arquivos (ainda com o conteúdo do modelo)
$ ls maquinas/lab01 maquinas/lab02 maquinas/lab03
maquinas/lab01:
inventario.txt  rede.conf

maquinas/lab02:
inventario.txt  rede.conf

maquinas/lab03:
inventario.txt  rede.conf

✔ Ponto de verificação C — as três máquinas têm 2 arquivos cada, modelos/ continua com os 2 originais intactos e descartes/ virou uma bancada bagunçada (é para isso que ela serve). Confirme que os modelos não foram alterados: ls -l modelos deve mostrar 52 e 57 bytes.

00:50 – 01:14 Parte D — cp -r com diretórios (passos 21 a 27) 24 min

Passo 21 — Cada máquina com a sua identidade

Antes de fazer o backup, personalize os arquivos. Como só temos echo, o jeito de "editar" é reescrever o arquivo inteiro: primeira linha com >, o resto com >>.

# ── lab01 ──
$ echo "maquina=LAB01" > maquinas/lab01/inventario.txt
$ echo "processador=i5" >> maquinas/lab01/inventario.txt
$ echo "memoria=8G" >> maquinas/lab01/inventario.txt
$ echo "disco=256G" >> maquinas/lab01/inventario.txt
$ echo "ip=192.168.0.11" > maquinas/lab01/rede.conf
$ echo "mascara=255.255.255.0" >> maquinas/lab01/rede.conf
$ echo "gateway=192.168.0.1" >> maquinas/lab01/rede.conf

# ── lab02 (esta tem o dobro de memória) ──
$ echo "maquina=LAB02" > maquinas/lab02/inventario.txt
$ echo "processador=i5" >> maquinas/lab02/inventario.txt
$ echo "memoria=16G" >> maquinas/lab02/inventario.txt
$ echo "disco=256G" >> maquinas/lab02/inventario.txt
$ echo "ip=192.168.0.12" > maquinas/lab02/rede.conf
$ echo "mascara=255.255.255.0" >> maquinas/lab02/rede.conf
$ echo "gateway=192.168.0.1" >> maquinas/lab02/rede.conf

# ── lab03 ──
$ echo "maquina=LAB03" > maquinas/lab03/inventario.txt
$ echo "processador=i5" >> maquinas/lab03/inventario.txt
$ echo "memoria=8G" >> maquinas/lab03/inventario.txt
$ echo "disco=256G" >> maquinas/lab03/inventario.txt
$ echo "ip=192.168.0.13" > maquinas/lab03/rede.conf
$ echo "mascara=255.255.255.0" >> maquinas/lab03/rede.conf
$ echo "gateway=192.168.0.1" >> maquinas/lab03/rede.conf

# Confira as três de uma vez — cat aceita vários arquivos
$ cat maquinas/lab01/rede.conf maquinas/lab02/rede.conf maquinas/lab03/rede.conf
ip=192.168.0.11
mascara=255.255.255.0
gateway=192.168.0.1
ip=192.168.0.12
mascara=255.255.255.0
gateway=192.168.0.1
ip=192.168.0.13
mascara=255.255.255.0
gateway=192.168.0.1

Cansativo, não? É de propósito. Reescrever um arquivo inteiro só para mudar uma linha é exatamente o problema que os editores (nano, vim) e ferramentas como sed resolvem — e que você vai aprender no próximo módulo. Sentir a dor primeiro faz a solução fazer muito mais sentido depois.

Passo 22 — O backup: copiando um diretório inteiro (`cp -r`)

# Sem -r, cp se recusa a copiar diretório (você viu isso no passo 19)
$ cp maquinas backup/
cp: -r not specified; omitting directory 'maquinas'

# -r = recursivo: copia o diretório e TUDO que existe dentro dele
$ cp -rv maquinas backup/
'maquinas' -> 'backup/maquinas'
'maquinas/lab01' -> 'backup/maquinas/lab01'
'maquinas/lab01/inventario.txt' -> 'backup/maquinas/lab01/inventario.txt'
'maquinas/lab01/rede.conf' -> 'backup/maquinas/lab01/rede.conf'
'maquinas/lab02' -> 'backup/maquinas/lab02'
'maquinas/lab02/inventario.txt' -> 'backup/maquinas/lab02/inventario.txt'
'maquinas/lab02/rede.conf' -> 'backup/maquinas/lab02/rede.conf'
'maquinas/lab03' -> 'backup/maquinas/lab03'
'maquinas/lab03/inventario.txt' -> 'backup/maquinas/lab03/inventario.txt'
'maquinas/lab03/rede.conf' -> 'backup/maquinas/lab03/rede.conf'
'maquinas/lab04' -> 'backup/maquinas/lab04'
'maquinas/lab04/turno-manha' -> 'backup/maquinas/lab04/turno-manha'

Um comando, doze linhas de trabalho. Repare que o lab04 criado por engano também foi copiado — o cp -r não julga, ele copia. Lição: faxina antes do backup. Vamos corrigir isso na Parte F.

Passo 23 — A pegadinha nº 1 do `cp -r`: destino que existe × destino que não existe

O mesmo comando faz duas coisas diferentes — e essa é a maior fonte de confusão com cp

# CASO 1 — o destino NÃO existe: ele VIRA a cópia (copia + renomeia)
$ cp -r maquinas/lab01 descartes/copia-lab01
$ ls -R descartes/copia-lab01
descartes/copia-lab01:
inventario.txt  rede.conf   # o conteúdo caiu direto aqui

# CASO 2 — o destino JÁ existe: a cópia entra DENTRO dele
$ cp -r maquinas/lab01 descartes/
$ ls -R descartes/lab01
descartes/lab01:
inventario.txt  rede.conf   # nasceu descartes/lab01/

Leia duas vezes: em cp -r origem destino, se destino não existe, ele é criado como cópia da origem. Se destino já existe, a origem é copiada para dentro dele. O mesmo comando, dois resultados — e é por isso que você deve rodar ls no destino antes, e usar -v para ver onde a cópia caiu.

Passo 24 — Copiar só o conteúdo de um diretório (`origem/.`)

# Quero o conteúdo da lab02 dentro de uma pasta com outro nome, sem aninhar
$ mkdir descartes/so-conteudo
$ cp -rv maquinas/lab02/. descartes/so-conteudo/
'maquinas/lab02/./inventario.txt' -> 'descartes/so-conteudo/./inventario.txt'
'maquinas/lab02/./rede.conf' -> 'descartes/so-conteudo/./rede.conf'

$ ls descartes/so-conteudo
inventario.txt  rede.conf   # sem a pasta lab02 no meio do caminho

O /. no final da origem quer dizer "o conteúdo desta pasta, não a pasta". Os caminhos esquisitos com /./ na saída do -v são normais: o cp só está ecoando o caminho como você digitou. Compare com o passo 23 e note que aqui não apareceu um lab02/ dentro do destino.

Passo 25 — `-a`: a cópia fiel, para backup de verdade

# -a (archive) = -r + preserva data, permissões, dono e links. É o -p do -r.
$ cp -a maquinas descartes/copia-fiel

# Compare as datas: a cópia -a mantém a data original...
$ ls -l --time-style=+%H:%M:%S descartes/copia-fiel/lab01
total 8
-rw-r--r-- 1 aluno aluno 51 09:52:10 inventario.txt
-rw-r--r-- 1 aluno aluno 57 09:52:14 rede.conf

# ...enquanto a cópia feita com -r no passo 22 tem a data da CÓPIA
$ ls -l --time-style=+%H:%M:%S backup/maquinas/lab01
total 8
-rw-r--r-- 1 aluno aluno 51 09:58:03 inventario.txt
-rw-r--r-- 1 aluno aluno 57 09:58:03 rede.conf

Regra prática: para copiar arquivos no dia a dia, cp -r basta. Para backup, use cp -a — perder a data de modificação de mil arquivos significa perder a resposta para "o que mudou desde ontem?".

Passo 26 — Conferindo o backup

$ ls -R backup
backup:
maquinas

backup/maquinas:
lab01  lab02  lab03  lab04

backup/maquinas/lab01:
inventario.txt  rede.conf

backup/maquinas/lab02:
inventario.txt  rede.conf

backup/maquinas/lab03:
inventario.txt  rede.conf

backup/maquinas/lab04:
turno-manha

backup/maquinas/lab04/turno-manha:

# Contagem: o backup deve ter os mesmos 6 arquivos que maquinas/
$ ls -lR backup | grep -c '^-'
6
$ ls -lR maquinas | grep -c '^-'
6

# E o conteúdo? Compare lado a lado com cat
$ cat maquinas/lab02/inventario.txt backup/maquinas/lab02/inventario.txt
maquina=LAB02
processador=i5
memoria=16G
disco=256G
maquina=LAB02
processador=i5
memoria=16G
disco=256G

Conferir backup contando arquivos e comparando conteúdo é o mínimo. (A ferramenta certa para comparar dois arquivos é o diff, e para dois diretórios, diff -r — você a verá no módulo de shell.)

Passo 27 — `-u`: copiar só o que mudou

# Simule uma alteração: toque em um arquivo (a data muda, o conteúdo não)
$ touch maquinas/lab01/inventario.txt

# -u ("update") só copia se a origem for MAIS NOVA que o destino
$ cp -ruv maquinas/. backup/maquinas/
'maquinas/./lab01/inventario.txt' -> 'backup/maquinas/./lab01/inventario.txt'

Uma linha só na saída: dos seis arquivos, apenas um estava mais novo que a cópia. É assim que backups incrementais funcionam — e é por isso que backup de 100 GB não precisa levar horas todo dia.

✔ Ponto de verificação D — explique em uma frase cada: (1) o que muda em cp -r a b se b existir ou não; (2) o que a/. significa como origem; (3) por que -a é melhor que -r para backup; (4) o que o -u compara antes de copiar.

01:14 – 01:30 Parte E — cp × mv (passos 28 a 32) 16 min

Passo 28 — A diferença, lado a lado, na mesma bancada

# Dois arquivos iguais para o experimento
$ echo "conteudo de teste" > descartes/para-copiar.txt
$ echo "conteudo de teste" > descartes/para-mover.txt
$ mkdir descartes/destino

# cp: sobram DOIS arquivos
$ cp -v descartes/para-copiar.txt descartes/destino/
'descartes/para-copiar.txt' -> 'descartes/destino/para-copiar.txt'

# mv: sobra UM arquivo
$ mv -v descartes/para-mover.txt descartes/destino/
renamed 'descartes/para-mover.txt' -> 'descartes/destino/para-mover.txt'

# A prova está na origem
$ ls descartes
alvo.txt  bloco.txt  com-p.conf  copia-fiel  copia-lab01  destino  fonte.txt  inventario-modelo.txt  lab01  para-copiar.txt  rede-modelo.conf  sem-p.conf  so-conteudo

$ ls descartes/destino
para-copiar.txt  para-mover.txt

Pergunta	`cp`	`mv`
O que sobra no final?	Dois arquivos (origem + cópia)	Um arquivo (só o destino)
Precisa de `-r` para diretórios?	Sim	Não
Quanto tempo leva com 10 mil arquivos?	Muito — copia byte a byte	Instantâneo (no mesmo disco)
Sobrescreve o destino sem avisar?	Sim	Sim
Como se proteger?	`-i` ou `-n`	`-i` ou `-n`
Preserva a data original?	Só com `-p` / `-a`	Sempre (é o mesmo arquivo)

Passo 29 — Por que o `mv` não precisa de `-r`

# mv move um diretório inteiro sem nenhuma opção especial
$ mv descartes/copia-lab01 descartes/lab01-antigo
$ ls -R descartes/lab01-antigo
descartes/lab01-antigo:
inventario.txt  rede.conf

# Já o cp exige o -r para a MESMA operação
$ cp descartes/lab01-antigo descartes/outra-copia
cp: -r not specified; omitting directory 'descartes/lab01-antigo'

O motivo é bonito: mv dentro do mesmo disco só troca o nome na tabela do diretório — o conteúdo não sai do lugar, então não há nada para "descer recursivamente". O cp, ao contrário, precisa ler e reescrever cada arquivo lá dentro — por isso ele exige que você diga explicitamente "sim, desça na árvore inteira" com -r.

Passo 30 — Mover vários arquivos de uma vez

# Sempre teste o curinga com ls antes
$ ls descartes/*.conf
descartes/com-p.conf  descartes/rede-modelo.conf  descartes/sem-p.conf

$ mkdir descartes/confs
$ mv -v descartes/*.conf descartes/confs/
renamed 'descartes/com-p.conf' -> 'descartes/confs/com-p.conf'
renamed 'descartes/rede-modelo.conf' -> 'descartes/confs/rede-modelo.conf'
renamed 'descartes/sem-p.conf' -> 'descartes/confs/sem-p.conf'

$ ls descartes/confs
com-p.conf  rede-modelo.conf  sem-p.conf

Passo 31 — A sobrescrita silenciosa do `mv` (e as duas defesas)

$ echo "SOU O A" > descartes/a.txt
$ echo "SOU O B" > descartes/b.txt

# mv sobre arquivo existente destrói o destino sem perguntar
$ mv descartes/a.txt descartes/b.txt
$ cat descartes/b.txt
SOU O A   # o conteúdo de B foi destruído e a.txt sumiu

# -i pergunta (responda n) e -n simplesmente não sobrescreve
$ echo "NOVO A" > descartes/a.txt
$ mv -i descartes/a.txt descartes/b.txt
mv: overwrite 'descartes/b.txt'? n

$ mv -n descartes/a.txt descartes/b.txt
$ ls descartes/a.txt descartes/b.txt
descartes/a.txt  descartes/b.txt   # os dois continuam vivos

Passo 32 — Copiar para depois mover: o padrão "cópia de segurança antes de mexer"

# Antes de alterar um arquivo de configuração, copie-o com data no nome
$ cp -v maquinas/lab03/rede.conf maquinas/lab03/rede.conf.bak
'maquinas/lab03/rede.conf' -> 'maquinas/lab03/rede.conf.bak'

# Agora "estrague" o original de propósito
$ echo "ip=ERRADO" > maquinas/lab03/rede.conf
$ cat maquinas/lab03/rede.conf
ip=ERRADO

# Restaure a partir da cópia — e apague o .bak para não sujar a pasta
$ cp -v maquinas/lab03/rede.conf.bak maquinas/lab03/rede.conf
'maquinas/lab03/rede.conf.bak' -> 'maquinas/lab03/rede.conf'

$ cat maquinas/lab03/rede.conf
ip=192.168.0.13
mascara=255.255.255.0
gateway=192.168.0.1

$ rm -v maquinas/lab03/rede.conf.bak
removed 'maquinas/lab03/rede.conf.bak'

Este é o hábito mais valioso deste exercício inteiro. Antes de editar qualquer arquivo de configuração de um servidor de verdade: cp arquivo.conf arquivo.conf.bak. Custa dois segundos e já salvou a carreira de muita gente.

✔ Ponto de verificação E — responda sem olhar: (1) por que mv de um diretório é instantâneo e cp -r não; (2) qual comando você roda antes de mexer em um arquivo de configuração; (3) o que mv -n faz de diferente do mv -i.

01:30 – 01:48 Parte F — Acidente e restauração (passos 33 a 38) 18 min

Leia antes de digitar: rm não tem lixeira e não tem desfazer. O único desfazer que existe no mundo real é o backup — que você fez no passo 22 e vai usar de verdade no passo 37. Confira o caminho duas vezes antes de cada Enter.

Passo 33 — Apagar arquivos: `rm`, `-i` e `-v`

# Material descartável
$ touch descartes/t1.log descartes/t2.log descartes/t3.log
$ ls descartes/*.log
descartes/t1.log  descartes/t2.log  descartes/t3.log

# rm simples: apaga e não diz nada
$ rm descartes/t1.log

# -i pergunta antes de cada arquivo (responda y)
$ rm -i descartes/t2.log
rm: remove regular empty file 'descartes/t2.log'? y

# -v mostra o que foi apagado — auditoria de graça
$ rm -v descartes/t3.log
removed 'descartes/t3.log'

Passo 34 — Curingas com `rm`: a regra de ouro

# NUNCA rode rm com curinga sem antes ver o que o padrão casa
$ pwd
/home/aluno/laboratorio
$ ls descartes/confs/*.conf
descartes/confs/com-p.conf  descartes/confs/rede-modelo.conf  descartes/confs/sem-p.conf

# Conferido o alvo, agora sim — e com -v para registrar
$ rm -v descartes/confs/*.conf
removed 'descartes/confs/com-p.conf'
removed 'descartes/confs/rede-modelo.conf'
removed 'descartes/confs/sem-p.conf'

$ ls descartes/confs
(vazio)

Os dois comandos que precedem todo rm com curinga: pwd (estou no lugar certo?) e ls PADRÃO (vou apagar exatamente isto?). Clássicos que já destruíram sistemas: rm -rf /, rm -rf * no diretório errado e rm -rf / caminho/x — um espaço a mais depois da barra vira "apague a raiz e a pasta x".

Passo 35 — Diretórios: `rmdir` × `rm -r` (e a faxina do lab04)

# rm comum se recusa a apagar diretório — proteção
$ rm descartes/confs
rm: cannot remove 'descartes/confs': Is a directory

# rmdir só funciona em diretório VAZIO — por isso é o mais seguro
$ rmdir descartes/confs
$ ls descartes/confs
ls: cannot access 'descartes/confs': No such file or directory

# Agora o lab04, criado por engano no passo 5. Ele está vazio?
$ ls -R maquinas/lab04
maquinas/lab04:
turno-manha

maquinas/lab04/turno-manha:

$ rmdir maquinas/lab04
rmdir: failed to remove 'maquinas/lab04': Directory not empty

# Duas saídas: esvaziar de dentro para fora com rmdir...
$ rmdir maquinas/lab04/turno-manha
$ rmdir maquinas/lab04

# ...e apagar a cópia dele que foi parar no backup, agora com rm -r
$ rm -rv backup/maquinas/lab04
removed directory 'backup/maquinas/lab04/turno-manha'
removed directory 'backup/maquinas/lab04'

$ ls maquinas backup/maquinas
backup/maquinas:
lab01  lab02  lab03

maquinas:
lab01  lab02  lab03

Pense no rmdir como cinto de segurança: ele só funciona quando não há nada a perder. Sempre que você acha que uma pasta está vazia, tente rmdir primeiro — se ele reclamar, você acabou de evitar um acidente.

Passo 36 — O acidente (proposital)

# Imagine que você quis apagar descartes/lab01 e digitou maquinas/lab02
$ rm -rv maquinas/lab02
removed 'maquinas/lab02/inventario.txt'
removed 'maquinas/lab02/rede.conf'
removed directory 'maquinas/lab02'

$ ls maquinas
lab01  lab03   # a lab02 sumiu do sistema

$ cat maquinas/lab02/inventario.txt
cat: maquinas/lab02/inventario.txt: No such file or directory

Sem lixeira, sem Ctrl+Z, sem "restaurar versão anterior". Se este fosse um servidor sem backup, a conversa acabaria aqui. Mas você fez o backup no passo 22.

Passo 37 — A restauração

# Passo 1: confirme que o backup realmente tem o que você perdeu
$ ls backup/maquinas/lab02
inventario.txt  rede.conf

# Passo 2: copie de volta. O destino maquinas/ existe → a pasta entra dentro dele
$ cp -rv backup/maquinas/lab02 maquinas/
'backup/maquinas/lab02' -> 'maquinas/lab02'
'backup/maquinas/lab02/inventario.txt' -> 'maquinas/lab02/inventario.txt'
'backup/maquinas/lab02/rede.conf' -> 'maquinas/lab02/rede.conf'

# Passo 3: CONFIRA. Restauração sem conferência não é restauração.
$ ls -R maquinas
maquinas:
lab01  lab02  lab03

maquinas/lab01:
inventario.txt  rede.conf

maquinas/lab02:
inventario.txt  rede.conf

maquinas/lab03:
inventario.txt  rede.conf

$ cat maquinas/lab02/inventario.txt
maquina=LAB02
processador=i5
memoria=16G
disco=256G   # tudo de volta, inclusive os 16G que só a lab02 tem

Guarde a sequência dos três passos: (1) confirmar que o backup tem o arquivo, (2) copiar de volta com -v, (3) conferir conteúdo com cat/ls. E lembre-se da regra do passo 23: como maquinas/ já existia, a pasta entrou dentro dele — que era exatamente o que queríamos. Se maquinas/ não existisse, o comando teria criado uma pasta maquinas com o conteúdo da lab02 dentro. Prever isso é a diferença entre restaurar e piorar.

Passo 38 — Faxina final

# SEMPRE confira onde está e o que vai apagar
$ pwd
/home/aluno/laboratorio
$ ls descartes
a.txt  alvo.txt  b.txt  bloco.txt  copia-fiel  destino  fonte.txt  inventario-modelo.txt  lab01  lab01-antigo  para-copiar.txt  so-conteudo

# -r apaga o diretório e TUDO que houver dentro. Sem volta.
$ rm -r descartes

$ ls -F
backup/  maquinas/  modelos/   # só o que deve ficar

✔ Ponto de verificação F — explique a diferença entre rmdir, rm -r e rm -rf; diga quais dois comandos precedem todo rm com curinga; e resuma em uma frase por que o passo 22 salvou o passo 36.

Conferência Final

Rode os comandos abaixo e compare com a saída esperada:

$ cd ~/laboratorio
$ pwd
/home/aluno/laboratorio

$ ls -R
.:
backup  maquinas  modelos

./backup:
maquinas

./backup/maquinas:
lab01  lab02  lab03

./backup/maquinas/lab01:
inventario.txt  rede.conf

./backup/maquinas/lab02:
inventario.txt  rede.conf

./backup/maquinas/lab03:
inventario.txt  rede.conf

./maquinas:
lab01  lab02  lab03

./maquinas/lab01:
inventario.txt  rede.conf

./maquinas/lab02:
inventario.txt  rede.conf

./maquinas/lab03:
inventario.txt  rede.conf

./modelos:
inventario-modelo.txt  rede-modelo.conf

# 14 arquivos no total: 6 em maquinas, 6 no backup e 2 modelos
$ ls -lR | grep -c '^-'
14

# Os modelos continuam intactos: 52 e 57 bytes, como no passo 10
$ ls -l modelos
total 8
-rw-r--r-- 1 aluno aluno 52 Sep  8 09:15 inventario-modelo.txt
-rw-r--r-- 1 aluno aluno 57 Sep  8 09:15 rede-modelo.conf

# As três máquinas com identidades diferentes
$ cat maquinas/lab01/inventario.txt maquinas/lab02/inventario.txt maquinas/lab03/inventario.txt
maquina=LAB01
processador=i5
memoria=8G
disco=256G
maquina=LAB02
processador=i5
memoria=16G
disco=256G
maquina=LAB03
processador=i5
memoria=8G
disco=256G

Autoavaliação — marque o que você concluiu

Criei pasta e subpasta em um único mkdir -p e sei explicar a idempotência do -p
Copiei um arquivo renomeando no mesmo comando
Sei a diferença entre destino arquivo e destino diretório no cp
Copiei vários arquivos de uma vez e sei por que o último argumento tem que ser diretório
Testei o curinga com ls antes de usá-lo com cp, mv e rm
Vi o cp sobrescrever sem avisar e sei usar -i e -n
Comprovei na prática o que o -p preserva
Copiei um diretório inteiro com cp -r
Sei prever onde a cópia vai parar quando o destino existe e quando não existe
Copiei apenas o conteúdo de um diretório com origem/.
Sei por que -a é a opção certa para backup e o que -u compara
Explico por que mv não precisa de -r e cp precisa
Adotei o hábito do cp arquivo.conf arquivo.conf.bak antes de editar
Apaguei um diretório por engano e restaurei do backup, conferindo o conteúdo
A estrutura final bate exatamente com a saída de ls -R acima

Exercícios Variados — 12 Mini-Desafios

Cada mini-desafio é independente e diz o objetivo, não o comando. Descubra o comando você mesmo. Faça todos dentro de ~/treino — crie a pasta com mkdir ~/treino e apague tudo no final com um único rm -r ~/treino. A "verificação" ao lado é o comando que prova que você acertou.

#	Objetivo	Dica	Verificação
1	Crie de uma só vez a árvore `~/treino/projeto/src/util` e `~/treino/projeto/docs`	Um único `mkdir`, dois caminhos	`ls -R ~/treino`
2	Crie 5 arquivos vazios `nota1.txt` … `nota5.txt` em `projeto/docs` com um comando só	`touch` aceita vários nomes	`ls -l projeto/docs` → 5 linhas com 0 bytes
3	Escreva 3 linhas em `nota1.txt` sem usar editor, e depois copie-o para `nota1-copia.txt`	`echo` com `>` e `>>`, depois `cp`	`cat nota1.txt nota1-copia.txt` → 6 linhas
4	Copie só os arquivos `.txt` de `docs` para `src`, mostrando cada cópia na tela	Curinga + `-v`. Teste o padrão com `ls` antes	`ls src`
5	Faça uma cópia do diretório `projeto` inteiro chamada `projeto-backup`, no mesmo nível	Destino que não existe vira a cópia	`ls -R projeto-backup` = `ls -R projeto`
6	Repita a cópia anterior preservando as datas dos arquivos, com o nome `projeto-fiel`	A opção "archive"	`ls -l projeto/docs` e `ls -l projeto-fiel/docs` com as mesmas horas
7	Crie `~/treino/entrega` e coloque lá o conteúdo de `projeto/docs` — sem criar uma pasta `docs` dentro	Lembre do `origem/.`	`ls entrega` → só os arquivos
8	Renomeie `nota5.txt` para `LEIA-ME.txt` e mova-o para a raiz de `projeto`	Pode ser um comando só	`ls projeto`
9	Copie `nota2.txt` por cima de `nota3.txt` sem destruir o nota3 — de duas formas diferentes	`-i` respondendo `n`, e `-n`	`cat nota3.txt` inalterado
10	Apague só os arquivos que terminam em `-copia.txt`, mostrando o que foi removido	`ls` no padrão antes, depois `rm -v`	`ls docs`
11	Apague `projeto/src/util` usando o comando que só funciona se estiver vazio	Se ele reclamar, esvazie antes	`ls projeto/src`
12	Simulação de desastre: apague `projeto/docs` inteiro e restaure-o a partir de `projeto-backup`, conferindo o conteúdo	`rm -r` e depois `cp -r`; atenção a onde a cópia vai cair	`ls -R projeto/docs` e `cat` de um arquivo

Terminou? Limpe a bancada com rm -r ~/treino — mas antes rode ls ~/treino e pwd, como manda a regra de ouro. Depois refaça os 12 do zero, cronometrando: a meta é menos de 10 minutos.

Desafio Individual

⚡ Desafio — "Migração do Laboratório"

Duração: 25 minutos | Formato: Individual, sem consultar o roteiro acima | Entregável: ~/desafio03/prova.txt

Missão

O laboratório ganhou uma sala nova e as máquinas vão migrar. Monte a estrutura abaixo em ~/desafio03 usando apenas os dez comandos deste exercício (pwd, ls, mkdir, cd, touch, cat, echo, cp, mv, rm) e os redirecionamentos > e >>. Nada de editores.

~/desafio03/
├── sala-nova/
│   ├── pc01/
│   │   ├── ficha.txt        (4 linhas, com maquina=PC01)
│   │   └── rede.conf        (3 linhas, ip terminando em .21)
│   ├── pc02/
│   │   ├── ficha.txt        (4 linhas, com maquina=PC02)
│   │   └── rede.conf        (3 linhas, ip terminando em .22)
│   └── pc03/
│       ├── ficha.txt        (4 linhas, com maquina=PC03)
│       └── rede.conf        (3 linhas, ip terminando em .23)
├── modelo/
│   ├── ficha-modelo.txt
│   └── rede-modelo.conf
├── backup/
│   └── sala-nova/           (cópia fiel de sala-nova, preservando datas)
└── prova.txt                (gerado no último passo)

Regras obrigatórias

Crie sala-nova/pc01, pc02, pc03, modelo e backup com no máximo dois mkdir
Os dois arquivos de modelo/ devem ser escritos uma única vez — as fichas das três máquinas nascem de cp, nunca de digitação repetida
A pc01 deve ser criada com cp renomeando no mesmo comando; a pc02, com um cp de vários arquivos + mv; a pc03, clonando a pc01
O backup tem que preservar as datas originais dos arquivos
Crie sala-nova/pc04 por engano e remova-o com o comando que só apaga pasta vazia
Simule o desastre: apague sala-nova/pc02 por completo e restaure-o do backup, provando com cat que o conteúdo voltou certo
Nenhum arquivo pode ficar com 0 bytes ao final (confira com ls -lR)
Os arquivos de modelo/ devem terminar intactos, com o mesmo tamanho do início

Passo final — gerar a prova

$ cd ~/desafio03
$ echo "Aluno: SEU NOME AQUI" > prova.txt
$ echo "Exercicio: 03 — Copias, Backup e Restauracao" >> 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 "--- fichas das maquinas ---" >> prova.txt
$ cat sala-nova/pc01/ficha.txt sala-nova/pc02/ficha.txt sala-nova/pc03/ficha.txt >> prova.txt
$ echo "--- pc02 restaurada do backup ---" >> prova.txt
$ cat sala-nova/pc02/rede.conf backup/sala-nova/pc02/rede.conf >> prova.txt

# Confira antes de entregar
$ cat prova.txt

Bônus (opcional)

Monte a estrutura inteira sem nunca usar cd — só com caminhos relativos e absolutos
Depois de tudo pronto, altere um arquivo e atualize o backup copiando apenas o que mudou
Crie ~/desafio03/entrega contendo o conteúdo de sala-nova/pc01 (sem a pasta pc01 no meio)
Refaça o desafio do zero em menos de 8 minutos, apagando tudo antes com um único rm -r ~/desafio03

Erros Comuns e Como Sair Deles

Mensagem / sintoma	O que realmente aconteceu	Como resolver
`cp: -r not specified; omitting directory 'x'`	A origem é um diretório e você não pediu cópia recursiva	Use `cp -r` (ou `cp -a`, para backup)
`cp: cannot stat 'x': No such file or directory`	A origem não existe — caminho ou nome errado	`pwd` e `ls` no diretório pai; use `Tab`
`cp: target 'x': Not a directory`	Você deu vários arquivos, mas o último argumento é um arquivo	Confirme o destino com `ls -ld destino` e termine com `/`
`cp: 'x' and 'x' are the same file`	Origem e destino apontam para o mesmo arquivo	Dê outro nome ao destino, ou copie para outro diretório
A cópia foi para o lugar errado (pasta aninhada demais)	O destino do `cp -r` já existia, então a origem entrou dentro dele	Reveja o passo 23; use `-v` para ver o destino real e `origem/.` quando quiser só o conteúdo
Todas as datas dos arquivos copiados ficaram iguais a "agora"	`cp` sem `-p`/`-a` cria arquivos novos	Refaça com `cp -a`
`cp: warning: behavior of -n is non-portable…`	Apenas um aviso do coreutils novo — o arquivo foi preservado	Prefira `--update=none` em scripts novos
`mkdir: ... No such file or directory`	Você pediu uma subpasta dentro de uma pasta que não existe	Use `mkdir -p`
`Directory not empty`	`rmdir` só remove diretórios vazios	Esvazie antes, ou use `rm -r` com atenção
`Is a directory`	`rm` ou `cat` recebeu uma pasta em vez de um arquivo	`rm -r` para apagar a pasta; `ls` para ver o conteúdo
Apaguei o arquivo errado	Não há lixeira nem desfazer no terminal	Restaure do backup (passo 37). Sem backup, não há solução — por isso o backup vem antes
O arquivo ficou vazio "do nada"	Você usou `>` onde queria `>>`	Reescreva. Adote `>>` como padrão
O terminal "travou" e não volta o `$`	Um comando aguarda entrada (aspas abertas, `cat` sem arquivo)	`Ctrl`+`C` cancela; `Ctrl`+`D` encerra a entrada

Referência Rápida dos 10 Comandos

cp — copiar (o novo)

cp a b          → copia renomeando
cp a dir/       → copia mantendo o nome
cp a b c dir/   → vários (destino = dir)
cp -v           → mostra origem -> destino
cp -i           → pergunta antes de sobrescrever
cp -n           → nunca sobrescreve
cp -p           → preserva data/dono/modo
cp -r dir1 dir2 → diretório inteiro
cp -a dir1 dir2 → -r + preserva tudo (backup)
cp -u           → só se a origem for mais nova
cp -r a/. b/    → só o CONTEÚDO de a

mv — mover / renomear

mv a b          → renomeia
mv a dir/       → move
mv a b c dir/   → move vários
mv dir1 dir2    → diretório (SEM -r)
mv -v           → mostra o que fez
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
ls PADRAO       → SEMPRE antes de rm PADRAO

mkdir — criar pastas

mkdir a         → uma pasta
mkdir a b c     → várias
mkdir -p a/b/c  → pasta/subpasta de uma vez
mkdir -pv a/b   → e diz o que criou
mkdir -p (2ª vez)→ não reclama

ls — o que existe

ls / ls -l      → nomes / detalhes
ls -a           → inclui ocultos
ls -lh          → tamanhos legíveis
ls -F           → marca tipo (/ @ *)
ls -t / -tr     → ordena por data
ls -ld DIR      → a pasta, não o conteúdo
ls -R           → desce nas subpastas
ls -lR | grep -c '^-'  → conta arquivos

cd / pwd — onde estou

pwd             → caminho atual
cd dir          → entra (relativo)
cd /a/b         → absoluto
cd ..  / ../..  → sobe um / dois níveis
cd ~  ou  cd    → home
cd -            → volta ao anterior

touch — criar / tocar

touch f         → cria vazio
touch f1 f2 f3  → vários
touch f (existe)→ só atualiza a data

echo — escrever

echo "$USER"    → expande variável
echo 'x'        → literal
echo -e "a\tb"  → interpreta \t \n
echo x >  f     → cria/SOBRESCREVE
echo x >> f     → ACRESCENTA

cat — ler / juntar

cat f           → mostra conteúdo
cat -n f        → numera as linhas
cat a b         → emenda na tela
cat a b > c     → emenda em arquivo

Checklist de Avaliação

Critério	Iniciante	Intermediário	Avançado
Estrutura de diretórios	Cria uma pasta por vez	Usa `mkdir -p` para pasta/subpasta	Monta a árvore toda em um ou dois comandos e explica a idempotência
`cp` com arquivos	Copia um arquivo para outro nome	Copia vários e usa curingas depois de testar com `ls`	Escolhe entre `-i`, `-n`, `-p` e `-v` justificando cada uma
`cp` com diretórios	Usa `cp -r` quando mandam	Sabe que o destino existente muda o resultado	Prevê o destino final sem rodar, usa `origem/.` e `-a` conscientemente
`cp` × `mv`	Confunde os dois	Sabe que `cp` deixa dois e `mv` deixa um	Explica por que `mv` dispensa `-r` e é instantâneo no mesmo disco
Remoção segura	Apaga um arquivo com `rm`	Distingue `rmdir` de `rm -r` e usa `-i`	Roda `pwd` + `ls PADRÃO` por reflexo antes de qualquer curinga
Backup e restauração	Copia a pasta quando mandam	Faz o backup e restaura seguindo o roteiro	Restaura sem roteiro, confere o conteúdo e explica por que o destino existente importa
Leitura de erros	Percebe que houve erro	Identifica a causa pela mensagem	Antecipa o erro antes de apertar Enter
Mini-desafios	Faz até 4 com ajuda	Faz de 5 a 9 sozinho	Faz os 12, incluindo a simulação de desastre, em menos de 10 minutos

Pontuação Sugerida

Iniciante — 0 a 5 pts

Completa os 38 passos seguindo o roteiro, mas erra o destino do cp -r quando não há orientação; não conclui o desafio sem ajuda.

Intermediário — 6 a 8 pts

Estrutura final correta, backup e restauração funcionando, conclui a maioria dos mini-desafios e explica cp × mv com clareza.

Avançado — 9 a 10 pts

Conclui desafio e bônus, prevê o destino de cada cp -r antes de rodar e restaura o desastre sem consultar nada.

Entrega

O que enviar

O conteúdo de ~/desafio03/prova.txt (copie e cole no formulário da disciplina)
A saída de ls -R ~/laboratorio mostrando a estrutura final do roteiro
Quantos dos 12 mini-desafios você concluiu sozinho
Em 3 linhas: descreva com suas palavras o que aconteceu nos passos 36 e 37 e o que você tirou disso

Comando único que gera tudo o que deve ser entregue

$ echo "=== ENTREGA — Exercicio 03 — SEU NOME ===" > ~/entrega03.txt
$ echo "Data: $(date '+%F %H:%M')" >> ~/entrega03.txt
$ echo "--- laboratorio ---" >> ~/entrega03.txt
$ ls -R ~/laboratorio >> ~/entrega03.txt
$ echo "--- contagem de arquivos (esperado: 14) ---" >> ~/entrega03.txt
$ ls -lR ~/laboratorio | grep -c '^-' >> ~/entrega03.txt
$ echo "--- desafio03 ---" >> ~/entrega03.txt
$ cat ~/desafio03/prova.txt >> ~/entrega03.txt
$ cat ~/entrega03.txt

Recursos e Referências

LPI (referência principal)

Documentação no próprio sistema

📖 man cp — leia as seções de -r, -a e -u
📖 man mv · man rm · man mkdir
📖 cp --help — resumo rápido de todas as opções
📖 cp --version — descubra sua versão do coreutils

Leitura complementar

Orientações Gerais

Como aproveitar melhor este exercício

Antes de cada cp, diga onde a cópia vai cair. Depois rode com -v e confira se você acertou — é o exercício mental mais valioso desta página
Rode ls no destino antes de um cp -r: saber se ele existe muda o resultado
Use Tab obsessivamente: além de poupar digitação, ele prova que o caminho existe
Rode pwd sempre 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 (rm -r ~/laboratorio) até conseguir sem olhar

Erros conceituais a evitar

Achar que cp -r a b faz sempre a mesma coisa — depende de b existir ou não
Esperar que cp preserve a data de modificação sem -p ou -a
Usar cp quando queria mv e ficar com duas cópias desatualizadas do mesmo arquivo
Tentar mv -r: essa opção não existe e nem é necessária
Digitar rm com curinga sem antes testar o padrão com ls
Chamar de "backup" uma cópia que nunca foi testada com uma restauração de verdade
Confundir / (raiz do sistema) com ~ (seu home)
Esquecer que nomes são sensíveis a maiúsculas: Lab01 ≠ lab01

Cópias, Backup e Restauração — 38 Passos