# Comandos Linux para AWS: o básico por tarefa, com shell script

> Os comandos Linux e de shell script para quem vai trabalhar com AWS, por tarefa: navegar, arquivos, permissões, processos, rede e scripts.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Carreira
- URL: https://pages.formacaoaws.com.br/blog/comandos-linux-para-aws/
- Aula de origem: "15 comandos Linux e Shell Script para um profissional que quer trabalhar com AWS e automação" (https://www.youtube.com/watch?v=m60wTVrzLdg)

Quem começa na AWS esbarra rápido em tela preta, comando Linux e shell script. Com a IA fazendo operação por você, não saber o que ela executa na nuvem é perigoso. Aqui estão os comandos do primeiro dia, por tarefa: navegar, mexer em arquivos, liberar permissão, olhar processos, testar rede e juntar tudo num script.

Eles vêm de duas aulas minhas: a de 2023, com 15 comandos, e a da [Missão Cloud de 2026, com 30 comandos](https://www.youtube.com/watch?v=NekPx6xlUkk). Cada comando aparece uma vez só.

## Onde rodar: CloudShell ou um container Ubuntu

Se você está no Windows, na máquina da empresa e não pode instalar nada, abra o **AWS CloudShell**: é o ícone na barra superior do console da AWS, com um terminal no navegador. O usuário é o `cloudshell-user` e a distribuição usa `yum` para instalar programas. Reiniciar o CloudShell apaga o que você instalou, o que serve bem para praticar. Instalação de verdade fica para uma máquina que você lançar na AWS.

A alternativa é um container Ubuntu, que roda em Mac e Windows. Uma versão mais recente do Ubuntu funciona igual:

```bash
docker run -it ubuntu:22.04 bash
```

Sobe o Ubuntu 22.04 e abre o terminal dentro dele. Em 2023 usei o CloudShell; em 2026, o container. Os exemplos valem para os dois.

**Fluxo:** Terminal (CloudShell ou Ubuntu) → Navegar e arquivos (pwd, ls, cd, cp, mv) → Permissões (sudo, chmod +x) → Shell script (variável, if, ./deploy.sh)

## Navegar: onde estou e o que tem aqui

```bash
pwd
ls
ls -la
```

`pwd` mostra o diretório atual (no container novo, a raiz `/`). `ls` lista arquivos e pastas. `ls -la` lista com detalhes e inclui os ocultos, os que começam com ponto: a `.git` e a `.kiro` do meu projeto só aparecem assim.

```bash
cd bia
cd ..
```

`cd` entra numa pasta; `cd ..` volta um nível. Digite só o começo do nome e aperte `Tab` para completar. Se houver nomes parecidos, o `Tab` completa até onde eles são iguais, e `Tab` duas vezes lista as opções.

```bash
clear
```

Limpa a tela. A seta para cima traz de volta os comandos que você já executou.

## Arquivos e pastas: criar, copiar, mover, apagar

```bash
mkdir aula-linux-shell
mv aula-linux-shell evento-aws
```

`mkdir` cria uma pasta. `mv` renomeia (como acima) ou move um arquivo ou pasta para outro lugar.

```bash
touch teste.sh
cat teste.sh
```

`touch` cria um arquivo vazio. `cat` mostra o conteúdo sem abrir editor; num arquivo vazio, não retorna nada.

```bash
cp teste.sh diretorio-teste
mv teste.sh diretorio-teste
```

`cp` copia: o original continua onde estava. `mv` move: o arquivo sai de onde estava e fica só no destino.

```bash
rm teste.sh
rm -rf diretorio-teste
```

`rm` remove um arquivo. `rm -rf` apaga a pasta e tudo que tem dentro, de forma recursiva e forçada, sem perguntar. Tenha cuidado com esse.

Para editar, uso o `nano` (tem quem prefira o VI):

```bash
nano primeiro_script.sh
```

Abre o arquivo para edição e, se ele não existir, cria. Para sair: `Ctrl X`, `Y` para salvar e `Enter` para manter o nome. Se você não alterou nada, o `Y` nem aparece. O nano precisa ser instalado, o que vem na próxima seção.

### Ler e filtrar

```bash
head -n 10 Dockerfile
tail -n 10 Dockerfile
tail -f arquivo.log
```

`head` mostra as primeiras linhas, `tail` as últimas. Com `-f`, o `tail` fica acompanhando o arquivo e mostra em tempo real o que chega. Na nuvem, serve para arquivo de log (o `arquivo.log` é só um nome de exemplo).

```bash
ls | grep primeiro
```

O `|` (pipe) passa o resultado do `ls` para o `grep`, que filtra só as linhas com o texto. Com 300 arquivos na pasta, você vê só os que têm "primeiro" no nome, com o trecho destacado em vermelho.

## Permissões e instalação

```bash
yum install nano
sudo yum install nano
```

Sem `sudo`, o `yum` responde "You need to be root to perform this command", porque o `cloudshell-user` não tem permissão para instalar. O `sudo` roda o comando como root. Se pedir confirmação, responda `y` e `Enter`.

![O yum sem sudo falha com "You need to be root to perform this command"; com sudo, o comando roda](https://pages.formacaoaws.com.br/blog/assets/posts/comandos-linux-para-aws/yum-install-precisa-de-sudo.webp)

```bash
sudo su
exit
```

`sudo su` faz os comandos seguintes rodarem como root; `exit` volta ao usuário anterior.

No Ubuntu, o gerenciador de pacotes é o `apt-get`; o comando muda conforme a distribuição:

```bash
apt-get update
apt-get install git -y
```

`apt-get update` atualiza a lista de pacotes. O Ubuntu não vem com Git, então instale antes de baixar um projeto. O `-y` confirma sem perguntar.

```bash
chmod +x teste.sh
./teste.sh
```

Arquivo recém-criado não tem permissão de execução, e `./teste.sh` falha. O `chmod +x` adiciona a permissão (x de execute) e o `./` executa. Use `Tab` depois do `./` para completar o nome.

## Processos e recursos da máquina

```bash
ps aux
kill -9 <PID>
```

`ps aux` lista os processos em execução, cada um com seu PID, o ID único dele. Se um processo travou, por exemplo num container, o `kill -9` com esse PID o mata de forma forçada.

```bash
watch ls
```

O `watch` repete o comando a cada 2 segundos. Útil quando o resultado vai mudando e você quer vê-lo atualizado.

```bash
df -h
free -m
```

`df -h` mostra o disco disponível e o percentual de uso. `free -m` mostra a memória: total, em uso e livre.

## Rede: baixar projeto e testar uma URL

```bash
git clone https://github.com/henrylle/bia
```

Baixa o projeto do GitHub e cria a pasta `bia`. É o que uso com os alunos: Node com React e banco PostgreSQL.

```bash
apt-get install curl -y
curl https://httpbin.org/get
curl -I https://httpbin.org/get
curl -I https://httpbin.org/status/500
```

O `curl` faz uma requisição pelo terminal. Na nuvem ele responde duas perguntas: a aplicação web está respondendo, e o servidor tem saída para a internet? O Ubuntu limpo não traz o `curl`, por isso o `apt-get install` vem antes. Sem argumento, devolve o resultado da requisição, no exemplo um JSON simples. Com `-I`, devolve o status HTTP: 200 é sucesso, e a última rota simula um erro 500, de servidor.

![O curl -I retorna HTTP/2 200 no topo, seguido dos cabeçalhos da resposta](https://pages.formacaoaws.com.br/blog/assets/posts/comandos-linux-para-aws/curl-status-http.webp)

## Shell script: juntar comandos em automação

Shell script é um arquivo `.sh`, escrito numa linguagem de script que roda comandos. É por ele que você constrói automação na nuvem. Existem interpretadores como `sh`, `dash` e `bash`; o mais comum, com mais possibilidades, é o bash. Para ficar compatível com ele, comece o arquivo declarando o interpretador:

```bash
#!/bin/bash
echo "Olá, mundo"
```

`echo` imprime. Salve, dê `chmod +x` e execute com `./primeiro_script.sh`.

### Variável e argumento

```bash
ambiente=PRD
echo $ambiente
```

Na atribuição, sem espaço em volta do `=` e sem cifrão. Na leitura, com cifrão. Para não deixar o valor fixo, troque `PRD` por `$1`: o script lê o primeiro argumento da chamada, e `./primeiro_script.sh prod` imprime `prod`. A imagem abaixo mostra a mesma ideia com `nome=$1`.

### Condicional

```bash
if [ -f deploy.sh ]; then
    echo "Arquivo de deploy existe"
else
    echo "Arquivo não encontrado"
fi
```

O `-f` verifica se o arquivo existe. Com `deploy.sh` na pasta, o script diz que existe. Removi o arquivo, rodei de novo, e ele disse que não foi encontrado.

![O script com nome=$1, o echo da saudação e o if [ -f deploy.sh ] com os dois caminhos](https://pages.formacaoaws.com.br/blog/assets/posts/comandos-linux-para-aws/script-variavel-e-if.webp)

### Um script que chama outros

Numa automação maior, com vários scripts, o `deploy.sh` chama os outros:

```bash
echo "Chamando primeiro script"
./primeiro_script.sh prod
echo "Chamando segundo script"
./segundo_script.sh
```

Para um script chamar outro, ele usa o `./` também, e todos precisam de `chmod +x`. Se um estiver sem permissão, o `deploy` não consegue chamá-lo.

### Guardar o resultado de um comando

```bash
arquivos=$(ls)
echo "Os arquivos desse diretorio sao:"
echo $arquivos
```

Escrever só `ls` na atribuição não executa nada. Com `$(ls)`, o comando roda e o resultado fica na variável `arquivos`. Juntar a variável a um texto se chama interpolação. Imprimi a lista num `echo` à parte porque ela vem com quebra de linha.

![O segundo_script.sh aberto com cat: arquivos=$(ls) guarda o resultado do ls e o echo imprime a lista](https://pages.formacaoaws.com.br/blog/assets/posts/comandos-linux-para-aws/cat-e-ls-dentro-do-script.webp)

### Encadear com &&

```bash
mkdir teste && mv teste.sh teste/
```

O `&&` executa o segundo comando depois do primeiro: cria a pasta e já move o arquivo para dentro, sem várias linhas repetindo operações. Num Dockerfile isso aparece muito: cada linha pode ser cacheada, e encadear as operações repetitivas as põe no mesmo bloco de cache.

## Checklist

- Abrir o CloudShell no console da AWS, ou subir um container com `docker run -it ubuntu:22.04 bash`.
- Navegar com `pwd`, `ls -la` e `cd`, usando `Tab` para completar.
- Criar, copiar, mover e apagar com `mkdir`, `touch`, `cp`, `mv` e `rm`, com cuidado no `rm -rf`.
- Ler com `cat`, `head` e `tail`, filtrar com `ls | grep` e editar com `nano`.
- Instalar com `sudo yum install` ou `apt-get install -y`.
- Liberar a execução com `chmod +x` e rodar com `./`.
- Consultar `ps aux`, `df -h` e `free -m`, e testar uma URL com `curl -I`.
- Escrever um script com `#!/bin/bash`, variável, `if [ -f ... ]` e `$(ls)`, e chamar um script a partir de outro.

Só ver alguém fazer não entra na cabeça, nem assistindo dez vezes. Repita cada comando no seu terminal e monte o seu próprio `deploy.sh`.