---
title: "Primeiros passos no terminal"
domain: cloud-computing
level: foundations
duration: "30 min"
objectives:
  - "Abrir um terminal em Windows (WSL), macOS ou Linux e explicar o que são um comando, um argumento e o prompt."
  - "Navegar entre pastas e listar o seu conteúdo com `pwd`, `ls` e `cd`."
  - "Criar, ler, copiar, mover e apagar ficheiros e pastas com `mkdir`, `touch`, `cat`, `cp`, `mv` e `rm`."
  - "Ler mensagens de erro e obter ajuda com `--help` e `man`."
lang: pt
source_hash: 971f61ae4796
---

# Primeiros passos no terminal

## Porque é que isto importa
Imagine que pede a um amigo que reorganize a sua coleção de fotografias. Podia ficar ao lado dele a apontar para cada fotografia. Ou podia entregar-lhe uma pequena lista de instruções escritas. A lista é mais rápida, pode ser verificada e, amanhã, pode ser entregue a outra pessoa com o mesmo resultado.

É esta a ideia do terminal. Em vez de clicar em ícones e menus, escrevem-se instruções curtas e o computador cumpre-as. Um servidor na cloud normalmente não tem ecrã, rato nem ambiente de trabalho: escrever é a única forma de comunicar com ele. Os laboratórios deste curso também usam um terminal, porque as instruções escritas são exatas, repetíveis e fáceis de copiar.

Parece intimidante: uma janela quase vazia com um cursor intermitente. Na prática, uma dúzia de comandos cobre quase tudo o que é preciso.

## Objetivos de aprendizagem
- Abrir um terminal em Windows (WSL), macOS ou Linux e explicar o que são um comando, um argumento e o prompt.
- Navegar entre pastas e listar o seu conteúdo com `pwd`, `ls` e `cd`.
- Criar, ler, copiar, mover e apagar ficheiros e pastas com `mkdir`, `touch`, `cat`, `cp`, `mv` e `rm`.
- Ler mensagens de erro e obter ajuda com `--help` e `man`.

## Conceitos-chave

### O que são um terminal e uma shell
Pense num restaurante. Diz-se ao empregado o que se quer, e o empregado traz o prato de uma cozinha que nunca se vê.

O **terminal** é a mesa: uma janela onde se escreve texto e se lê texto. A **shell** (interpretador de comandos) é o empregado: um programa que lê o que foi escrito, pede ao computador que o execute e devolve a resposta em texto. A shell mais comum em Linux chama-se **bash**; a predefinida em macOS é a **zsh** (pronuncia-se "zi-shél"). Para os comandos deste módulo, comportam-se da mesma forma.

![Três cartões ligados por setas. À esquerda, o utilizador: escreve um comando e prime Enter. Ao centro, o terminal e a shell: o terminal é a janela e a shell lê o comando. À direita, o computador: executa o programa e devolve o resultado. Uma seta com a legenda comando, em texto, vai da esquerda para a direita; uma segunda seta com a legenda resultado, em texto, volta da direita para a esquerda.](../../../assets/diagrams/terminal-how-it-works.pt.svg)

*Figura 1. Escreve-se um comando como texto; a shell passa-o ao computador e apresenta o resultado como texto.*

> [!CHECK]
> Na comparação com o restaurante, que parte é a shell?
>
> - [ ] A mesa onde se está sentado: a janela onde se escreve
> - [x] O empregado: o programa que lê o comando e traz o resultado
> - [ ] A cozinha: os ficheiros do computador
>
> O terminal é a janela. A shell é o programa que está lá dentro e que lê e executa o que se escreve.

### O prompt, os comandos, as opções e os argumentos
Ao abrir um terminal, vê-se uma linha de texto e um cursor intermitente. Essa linha é o **prompt**. Significa "estou pronto, escreva alguma coisa". Mostra muitas vezes o nome de utilizador, o nome do computador e a pasta em que se está, e termina em `$` (bash) ou `%` (zsh). O prompt já lá está: nunca se escreve. Os comandos de exemplo deste módulo omitem-no, para que possam ser copiados diretamente.

O que se escreve é um **comando**: o nome de um programa a executar. Termina-se premindo Enter. Muitos comandos aceitam dois outros tipos de palavras:

- Uma **opção** (também chamada flag) altera o funcionamento do comando. Costuma começar por um hífen: `-l`, ou por dois hífenes quando tem um nome longo: `--help`.
- Um **argumento** indica ao comando aquilo sobre que deve atuar, como o nome de um ficheiro ou de uma pasta.

As palavras separam-se por espaços, e as maiúsculas contam: `Photos` e `photos` são nomes diferentes.

![A linha user@laptop:~$ ls -l photos dividida em quatro partes coloridas. O prompt, user@laptop:~$, indica que o terminal está pronto; já lá está e não se escreve. O comando, ls, é o programa que se quer executar. A opção, -l, altera o funcionamento do comando; as opções costumam começar por um hífen. O argumento, photos, é aquilo sobre que o comando atua, um ficheiro ou uma pasta. Depois de escrever, prime-se Enter.](../../../assets/diagrams/terminal-command-anatomy.pt.svg)

*Figura 2. Escrevem-se apenas o comando, as suas opções e os seus argumentos. O prompt já lá está.*

> [!CHECK]
> Em `ls -l photos`, o que é `photos`?
>
> - [ ] O comando
> - [ ] Uma opção
> - [x] Um argumento
>
> `ls` é o comando, `-l` é uma opção e `photos` é o argumento: a pasta sobre a qual atuar.

### Pastas e caminhos
O computador guarda tudo em **pastas** (também chamadas **diretórios**), e as pastas podem conter outras pastas, como um arquivo. Visto de cima, é uma árvore.

No topo da árvore está a **pasta raiz**, escrita `/`. Tudo o que existe no computador está dentro dela. Dentro da raiz, uma pasta chamada `home` guarda uma pasta por pessoa. A sua é a **pasta pessoal** (home), o local onde vivem os seus próprios ficheiros. O atalho `~` (chamado til) significa sempre "a minha pasta pessoal".

Um **caminho** é o endereço de um ficheiro ou de uma pasta: a lista de pastas por que é preciso passar, separadas por `/`.

- Um **caminho absoluto** começa por `/` e funciona a partir de qualquer lado, como uma morada postal completa: `/home/user/terminal-practice/notes`.
- Um **caminho relativo** parte da pasta em que se está, como dizer "ao lado": `notes` significa "a pasta chamada notes que está aqui mesmo".

Dois nomes especiais ajudam com os caminhos relativos: `.` significa "esta pasta" e `..` significa "a pasta acima desta".

![Uma árvore de pastas lida da esquerda para a direita. A pasta raiz, escrita /, é o topo de tudo. Dentro dela está home e depois user, que é a sua pasta pessoal e também se escreve ~. Dentro de user está terminal-practice, que contém duas pastas: notes, com o ficheiro todo.txt, e photos, com o ficheiro cat.jpg. Por baixo da árvore há três cartões. Um caminho absoluto começa por uma barra e funciona a partir de qualquer lado, por exemplo /home/user/terminal-practice/notes. Um caminho relativo parte da pasta em que está, pelo que, a partir de terminal-practice, é apenas notes. Dois atalhos: um ponto significa a pasta atual e dois pontos a pasta acima.](../../../assets/diagrams/terminal-folder-tree.pt.svg)

*Figura 3. A árvore de pastas. Pode chegar-se à mesma pasta com um caminho absoluto ou com um relativo, consoante o local onde se está.*

O terminal tem sempre uma **pasta atual**, o local onde está "de pé". Um terminal novo começa na pasta pessoal. Três comandos permitem olhar à volta e navegar:

| Comando | O que faz | Exemplo |
|---|---|---|
| `pwd` | **P**rints the **w**orking **d**irectory (mostra o diretório de trabalho): onde se está agora | `pwd` |
| `ls` | **L**i**s**ta o que existe numa pasta. `-l` mostra detalhes (tamanho, data); `-a` mostra também os itens ocultos, cujos nomes começam por um ponto | `ls -l` |
| `cd` | **C**hange **d**irectory (muda de diretório). `cd` sozinho volta à pasta pessoal | `cd notes`, `cd ..`, `cd ~/photos` |

> [!CHECK]
> Está em `/home/user/terminal-practice/notes`. Que comando leva a `/home/user/terminal-practice`?
>
> - [ ] `cd .`
> - [x] `cd ..`
> - [ ] `cd ~`
>
> `..` significa a pasta acima. `.` é a pasta em que já se está, e `~` leva à pasta pessoal, que está mais acima.

### Trabalhar com ficheiros e pastas
Quando já se sabe navegar, estes comandos criam e manipulam coisas. O padrão é sempre o mesmo: o comando e, depois, aquilo sobre que atua.

| Comando | O que faz | Exemplo |
|---|---|---|
| `mkdir` | Cria uma pasta | `mkdir photos` |
| `touch` | Cria um ficheiro vazio (ou atualiza a data de um que já exista) | `touch todo.txt` |
| `echo` | Imprime texto. Com `>`, o texto vai para um ficheiro em vez de ir para o ecrã | `echo "Buy milk" > todo.txt` |
| `cat` | Imprime o conteúdo de um ficheiro | `cat todo.txt` |
| `cp` | Copia: `cp <origem> <destino>` | `cp todo.txt backup.txt` |
| `mv` | Move ou renomeia: `mv <origem> <destino>` | `mv backup.txt old.txt` |
| `rm` | Remove (apaga) um ficheiro | `rm old.txt` |
| `clear` | Limpa o ecrã (os ficheiros não são afetados) | `clear` |

Alguns pormenores evitam surpresas a quem está a começar:

- `>` escreve texto num ficheiro e **substitui o que lá estava**. `>>` acrescenta no fim. Ambos se chamam **redirecionamento**: a saída vai para um ficheiro em vez de ir para o ecrã.
- `mv` faz dois trabalhos: se o destino for um nome novo, renomeia; se o destino for uma pasta, move o ficheiro para dentro dela.
- Para apagar uma pasta, usa-se `rm -r <pasta>`: a opção `-r` significa "recursivo", a pasta e tudo o que contém.

> [!WARNING]
> `rm` **não tem reciclagem**. Um ficheiro apagado desaparece, sem desfazer. Leia o comando duas vezes e tenha muito cuidado com `rm -r`.

Duas funcionalidades facilitam a escrita. O **histórico**: prime-se a seta para cima para recuperar comandos anteriores e depois Enter para os executar de novo. E o **preenchimento automático com Tab**: escrevem-se as primeiras letras de um nome e prime-se Tab, e a shell completa-o. Poupa escrita e evita gralhas.

> [!CHECK]
> O que faz `mv draft.txt final.txt` quando não existe nenhum ficheiro chamado `final.txt`?
>
> - [ ] Copia `draft.txt` para `final.txt` e mantém ambos
> - [x] Renomeia `draft.txt` para `final.txt`
> - [ ] Apaga `draft.txt`, porque é "movido" para lado nenhum
>
> `mv` move um ficheiro para um novo nome ou local. Movê-lo dentro da mesma pasta para um novo nome é renomeá-lo. O nome original desaparece.

### Ler erros e pedir ajuda
Uma gralha produz uma mensagem de erro. Não é uma falha: é o computador a dizer, em texto, o que não percebeu. Há três que surgem constantemente.

![Três cartões. Command not found: escreveu mal o comando ou não está instalado, como em pwdd; verifique a ortografia. No such file or directory: o nome está errado ou está numa pasta diferente, como em cat shopping.txt; use pwd e ls para se orientar. Permission denied: o sistema não o deixa fazer isso com este ficheiro, como em cat /etc/shadow; costuma ser uma proteção, por isso não force. As mensagens do terminal aparecem em inglês.](../../../assets/diagrams/terminal-errors.pt.svg)

*Figura 4. Três erros comuns, um exemplo que provoca cada um e o que fazer.*

A redação varia: a bash diz `bash: pwdd: command not found`; a zsh em macOS diz `zsh: command not found: pwdd`. O terminal apresenta estas mensagens em inglês (ou no idioma do sistema, consoante a configuração), por isso aparecem em inglês nos blocos de código deste módulo.

Quando não se sabe como funciona um comando, pergunta-se-lhe:

- A maioria dos comandos de Linux aceita `--help`, que imprime um resumo curto: `mkdir --help`.
- `man <comando>` (abreviatura de **manual**) abre a **página de manual** completa de um comando: `man ls`. Use as setas ou a barra de espaços para percorrer, `/palavra` para pesquisar e `q` para sair. Não se esqueça do `q`: é a saída.

> [!NOTE]
> Em macOS, muitos comandos incluídos não percebem `--help`; use `man` aí. Algumas instalações mínimas de Linux ou de WSL não têm páginas de manual (`No manual entry`); use `--help` em alternativa.

> [!CHECK]
> Escreve `cat notes.txt` e vê `No such file or directory`. Qual é o primeiro passo mais útil?
>
> - [ ] Reinstalar o terminal
> - [x] Executar `pwd` e `ls` para verificar onde se está e o que existe na pasta
> - [ ] Executar o comando de novo com `rm` à frente
>
> A mensagem costuma indicar um nome errado ou a pasta errada. Olhar à volta com `pwd` e `ls` mostra qual das duas.

## Como funciona
Quando se prime Enter, acontecem quatro coisas:

1. A shell divide a linha em palavras: a primeira é o comando; as restantes são opções e argumentos.
2. Procura um programa com esse nome. Se não existir nenhum, obtém-se `command not found`.
3. Inicia o programa e entrega-lhe as opções e os argumentos.
4. O programa faz o seu trabalho, imprime o resultado, se o houver, e termina. O prompt regressa.

### Abrir um terminal no seu computador
- **Windows.** Os laboratórios usam comandos de Linux, e a forma mais fácil de ter Linux no Windows é o **WSL** (Windows Subsystem for Linux, subsistema do Windows para Linux), uma funcionalidade da Microsoft que executa Linux dentro do Windows. Abra o menu Iniciar, procure PowerShell, clique com o botão direito e escolha **Executar como administrador**. Escreva `wsl --install`, prima Enter, aguarde e reinicie o PC quando for pedido. Depois abra o **Ubuntu** a partir do menu Iniciar; à primeira vez, é pedido que escolha um nome de utilizador e uma palavra-passe (enquanto se escreve a palavra-passe não aparece nada no ecrã: é normal). Consulte o guia da Microsoft nas Referências. Alguns PC de empresas ou escolas bloqueiam o WSL: consulte a equipa de TI ou use uma máquina Linux.
- **macOS.** Prima Cmd + Espaço, escreva `Terminal` e prima Enter. Executa a zsh, e os comandos deste módulo comportam-se da mesma forma.
- **Linux.** Procure no menu uma aplicação chamada Terminal, Konsole ou semelhante. Em muitos ambientes de trabalho, Ctrl + Alt + T abre-a.

## Exemplo prático
Está a preparar a bagagem para uma viagem e quer uma pasta para as notas e fotografias. Leia cada linha e compare depois com a saída.

```bash
mkdir -p trip/photos
cd trip
echo "Passport, charger, umbrella" > packing.txt
cp packing.txt packing-v1.txt
mv packing-v1.txt photos/
ls
ls photos
cat packing.txt
```

Saída esperada:
```text
packing.txt  photos
packing-v1.txt
Passport, charger, umbrella
```

(`ls` imprime em colunas quando partilha a linha, como aqui; o que importa são os nomes, não o espaçamento.)

- `mkdir -p trip/photos` cria `trip` e, dentro dela, `photos`. A opção `-p` cria de uma só vez as pastas superiores em falta.
- `cd trip` entra na pasta nova. `echo ... > packing.txt` cria o ficheiro com esse texto.
- `cp` faz uma cópia, e `mv` move a cópia para `photos/`.
- O primeiro `ls` mostra o que existe em `trip`, o segundo o que existe em `photos`, e `cat` imprime o texto do ficheiro.

Os comandos que têm êxito normalmente não imprimem nada. O silêncio significa "feito".

## Erros comuns
- **Escrever o prompt.** Copiar `$ ls` ou `user@laptop:~$ ls` para o terminal falha. Escreva apenas o que vem depois do prompt.
- **Maiúsculas e gralhas.** `Notes` não é `notes`. Use o preenchimento automático com Tab para evitar erros.
- **Espaços nos nomes.** `mkdir my notes` cria duas pastas. Use hífenes (`my-notes`) ou aspas.
- **Substituir com `>`.** `echo "new" > file.txt` substitui o conteúdo anterior. Use `>>` para acrescentar.
- **Não saber onde se está.** Muitos erros resultam de se estar na pasta errada. `pwd` é gratuito: use-o com frequência.

## Considerações de segurança
O terminal faz exatamente o que lhe é dito, com as mesmas permissões que o utilizador tem. Alguns hábitos mantêm-no seguro:

- Execute apenas comandos que compreenda. Tenha cuidado com comandos copiados de sites, conversas ou vídeos: leia-os primeiro e pesquise qualquer parte que não conheça.
- `rm` não pode ser desfeito. Verifique o caminho antes de premir Enter e nunca execute `rm -r` numa pasta que não tenha consultado com `ls`.
- Alguns comandos começam por `sudo`, que os executa com todos os poderes de administrador. Os laboratórios deste módulo nunca precisam dele. Se um comando começar por `sudo` e não se perceber porquê, pare e pergunte.
- Uma mensagem `Permission denied` é, muitas vezes, o sistema a proteger ficheiros importantes. Não procure forma de a contornar.

## Resumo
- O terminal é uma janela para escrever instruções; a shell executa-as. É preciso, repetível e funciona em servidores sem ecrã.
- Uma linha de comandos é um comando, seguido de opções (que alteram o comportamento) e argumentos (aquilo sobre que atuar). Nunca se escreve o prompt.
- Os ficheiros vivem numa árvore de pastas. `~` é a pasta pessoal, `.` é aqui, `..` é um nível acima. Os caminhos são absolutos (começam por `/`) ou relativos.
- `pwd`, `ls` e `cd` permitem olhar à volta; `mkdir`, `touch`, `echo >`, `cat`, `cp`, `mv` e `rm` criam e alteram coisas. `rm` não tem como desfazer.
- Os erros são mensagens para ler: `command not found`, `No such file or directory` e `Permission denied` apontam cada um para uma causa concreta. `--help` e `man` explicam qualquer comando.

## Glossário
| Termo | Definição |
|---|---|
| terminal | Uma janela onde se escrevem comandos de texto e se leem resultados em texto. |
| shell | O programa dentro do terminal que lê os comandos e os executa. |
| bash, zsh | Duas shells comuns: bash na maioria dos sistemas Linux, zsh em macOS. |
| prompt | O texto antes do cursor que indica que o terminal está pronto. Não se escreve. |
| comando | O nome do programa que se pede à shell que execute, como `ls`. |
| opção (flag) | Uma palavra, normalmente iniciada por `-`, que altera o funcionamento de um comando. |
| argumento | Uma palavra que indica a um comando aquilo sobre que atuar, como o nome de um ficheiro ou de uma pasta. |
| pasta (diretório) | Um contentor que guarda ficheiros e outras pastas. |
| pasta raiz | O topo da árvore de pastas, escrita `/`. |
| pasta pessoal (home) | A pasta pessoal do utilizador, escrita `~`. |
| caminho | O endereço de um ficheiro ou pasta, como nomes de pastas separados por `/`. |
| caminho absoluto | Um caminho que começa por `/` e funciona a partir de qualquer lado. |
| caminho relativo | Um caminho que parte da pasta atual. |
| pasta atual | A pasta em que o terminal está "de pé"; `pwd` mostra-a. |
| redirecionamento | Enviar a saída de um comando para um ficheiro com `>` (substituir) ou `>>` (acrescentar) em vez de para o ecrã. |
| histórico | A lista de comandos escritos anteriormente; a seta para cima recupera-os. |
| preenchimento automático com Tab | Premir Tab para que a shell complete um nome que se começou a escrever. |
| página de manual (man page) | O manual completo de um comando, aberto com `man <comando>`. |
| WSL | Windows Subsystem for Linux: uma funcionalidade do Windows que executa Linux dentro do Windows. |

## Verifique o que aprendeu
1. Explique em duas frases porque é que um engenheiro de cloud prefere comandos escritos a clicar.
2. Está na pasta pessoal e quer ler `/home/user/terminal-practice/notes/todo.txt`. Escreva um comando com um caminho absoluto e outro com um caminho relativo.
3. Um colega diz: "`rm` moveu o meu ficheiro para a reciclagem, posso recuperá-lo". Que resposta lhe daria?

## Referências
- [Install WSL — Microsoft Learn](https://learn.microsoft.com/en-us/windows/wsl/install)
- [The Linux command line for beginners — Ubuntu tutorial](https://ubuntu.com/tutorials/command-line-for-beginners)
- [Terminal User Guide — Apple Support](https://support.apple.com/guide/terminal/welcome/mac)
- [GNU Coreutils manual](https://www.gnu.org/software/coreutils/manual/coreutils.html)
