Phase 00 - Lesson 11

Linux para IA

A maior parte da IA roda em Linux. Você precisa saber o suficiente para não ficar travado.

Tipo: Aprender Linguagens: -- Pré-requisitos: Fase 0, Lição 01 Tempo: ~30 minutos

Objetivos de Aprendizagem

• Navegar pelo sistema de arquivos do Linux e realizar operações essenciais de arquivos pela linha de comando
• Gerenciar permissões de arquivos com chmod e chown para resolver erros de "Permission denied"
• Instalar pacotes de sistema com apt e configurar uma máquina de GPU nova para trabalho com IA
• Identificar diferenças between macOS e Linux que comumente confundem desenvolvedores que trabalham em máquinas remotas

O Problema

Você desenvolve no macOS ou no Windows. Mas no momento em que conecta via SSH a uma máquina de GPU na nuvem, aluga uma instância Lambda ou sobe uma máquina EC2, você cai no Ubuntu. O terminal é sua única interface. Não há Finder, não há Explorer, não há GUI. Se você não consegue navegar pelo sistema de arquivos, instalar pacotes e gerenciar processos pela linha de comando, você fica travado pagando por horas ociosas de GPU enquanto procura no Google "como descompactar um arquivo no Linux".

Este é um guia de sobrevivência. Ele cobre exatamente o que você precisa para operar em uma máquina Linux remota para trabalho com IA. Nada além disso.

Estrutura do Sistema de Arquivos

O Linux organiza tudo sob uma única raiz /. Não há C: nem /Volumes. Os diretórios que você realmente vai usar:

graph TD
    root["/"] --> home["home/your-username/<br/>Your files — clone repos, run training"]
    root --> tmp["tmp/<br/>Temporary files, cleared on reboot"]
    root --> usr["usr/<br/>System programs and libraries"]
    root --> etc["etc/<br/>Config files"]
    root --> varlog["var/log/<br/>Logs — check when something breaks"]
    root --> mnt["mnt/ or /media/<br/>External drives and volumes"]
    root --> proc["proc/ and /sys/<br/>Virtual files — kernel and hardware info"]

Seu diretório home é ~ ou /home/your-username. Quase tudo o que você faz acontece aqui.

Comandos Essenciais

Estes são os 15 comandos que cobrem 95% do que você vai fazer em uma máquina de GPU remota.

Movendo-se

pwd                         # Where am I?
ls                          # What's here?
ls -la                      # What's here, including hidden files with details?
cd /path/to/dir             # Go there
cd ~                        # Go home
cd ..                       # Go up one level

Arquivos e Diretórios

mkdir my-project            # Create a directory
mkdir -p a/b/c              # Create nested directories in one shot

cp file.txt backup.txt      # Copy a file
cp -r src/ src-backup/      # Copy a directory (recursive)

mv old.txt new.txt          # Rename a file
mv file.txt /tmp/           # Move a file

rm file.txt                 # Delete a file (no trash, it's gone)
rm -rf my-dir/              # Delete a directory and everything inside

rm -rf é permanente. Não há desfazer. Verifique o caminho duas vezes antes de apertar enter.

Lendo Arquivos

cat file.txt                # Print entire file
head -20 file.txt           # First 20 lines
tail -20 file.txt           # Last 20 lines
tail -f log.txt             # Follow a log file in real time (Ctrl+C to stop)
less file.txt               # Scroll through a file (q to quit)

Buscando

grep "error" training.log           # Find lines containing "error"
grep -r "learning_rate" .           # Search all files in current directory
grep -i "cuda" config.yaml          # Case-insensitive search

find . -name "*.py"                 # Find all Python files under current dir
find . -name "*.ckpt" -size +1G     # Find checkpoint files larger than 1GB

Permissões

Todo arquivo no Linux tem um dono e bits de permissão. Você vai esbarrar nisso quando scripts não executarem ou você não conseguir escrever em um diretório.

ls -l train.py
# -rwxr-xr-- 1 user group 2048 Mar 19 10:00 train.py
#  ^^^             owner permissions: read, write, execute
#     ^^^          group permissions: read, execute
#        ^^        everyone else: read only

Correções comuns:

chmod +x train.sh           # Make a script executable
chmod 755 deploy.sh         # Owner: full, others: read+execute
chmod 644 config.yaml       # Owner: read+write, others: read only

chown user:group file.txt   # Change who owns a file (needs sudo)

Quando algo diz "Permission denied", quase sempre é um problema de permissões. chmod +x ou sudo resolve a maioria dos casos.

Gerenciamento de Pacotes (apt)

O Ubuntu usa apt. É assim que você instala software de nível de sistema.

sudo apt update             # Refresh the package list (always do this first)
sudo apt install -y htop    # Install a package (-y skips confirmation)
sudo apt install -y build-essential  # C compiler, make, etc. Needed by many Python packages
sudo apt install -y tmux    # Terminal multiplexer (keep sessions alive after disconnect)

apt list --installed        # What's installed?
sudo apt remove htop        # Uninstall

Pacotes comuns que você vai instalar em uma máquina de GPU nova:

sudo apt update && sudo apt install -y 
    build-essential 
    git 
    curl 
    wget 
    tmux 
    htop 
    unzip 
    python3-venv

Usuários e sudo

Você geralmente está logado como um usuário comum. Algumas operações precisam de acesso root (administrador).

whoami                      # What user am I?
sudo command                # Run a single command as root
sudo su                     # Become root (exit to go back, use sparingly)

Em instâncias de GPU na nuvem, você normalmente é o único usuário e já tem acesso sudo. Não rode tudo como root. Use sudo apenas quando necessário.

Processos e systemd

Quando seu treinamento trava, ou você precisa verificar o que está rodando:

htop                        # Interactive process viewer (q to quit)
ps aux | grep python        # Find running Python processes
kill 12345                  # Gracefully stop process with PID 12345
kill -9 12345               # Force kill (use when graceful doesn't work)
nvidia-smi                  # GPU processes and memory usage

O systemd gerencia serviços (daemons em segundo plano). Você vai usá-lo se rodar servidores de inferência:

sudo systemctl start nginx          # Start a service
sudo systemctl stop nginx           # Stop it
sudo systemctl restart nginx        # Restart it
sudo systemctl status nginx         # Check if it's running
sudo systemctl enable nginx         # Start automatically on boot

Espaço em Disco

Máquinas de GPU costumam ter espaço em disco limitado. Modelos e datasets enchem rápido.

df -h                       # Disk usage for all mounted drives
df -h /home                 # Disk usage for /home specifically

du -sh *                    # Size of each item in current directory
du -sh ~/.cache             # Size of your cache (pip, huggingface models land here)
du -sh /data/checkpoints/   # Check how big your checkpoints are

# Find the biggest space hogs
du -h --max-depth=1 / 2>/dev/null | sort -hr | head -20

Economizadores de espaço comuns:

# Clear pip cache
pip cache purge

# Clear apt cache
sudo apt clean

# Remove old checkpoints you don't need
rm -rf checkpoints/epoch_01/ checkpoints/epoch_02/

Rede

Você vai baixar modelos, transferir arquivos e acessar APIs pela linha de comando.

# Download files
wget https://example.com/model.bin                   # Download a file
curl -O https://example.com/data.tar.gz              # Same thing with curl
curl -s https://api.example.com/health | python3 -m json.tool  # Hit an API, pretty-print JSON

# Transfer files between machines
scp model.bin user@remote:/data/                     # Copy file to remote machine
scp user@remote:/data/results.csv .                  # Copy file from remote to local
scp -r user@remote:/data/checkpoints/ ./local-dir/   # Copy directory

# Sync directories (faster than scp for large transfers, resumes on failure)
rsync -avz --progress ./data/ user@remote:/data/
rsync -avz --progress user@remote:/results/ ./results/

Use rsync em vez de scp para qualquer coisa grande. Ele transfere apenas os bytes que mudaram e lida com conexões interrompidas.

tmux: Mantenha as Sessões Vivas

Quando você conecta via SSH a uma máquina remota, fechar o laptop encerra sua execução de treinamento. O tmux evita isso.

tmux new -s train           # Start a new session named "train"
# ... start your training, then:
# Ctrl+B, then D            # Detach (training keeps running)

tmux ls                     # List sessions
tmux attach -t train        # Reattach to session

# Inside tmux:
# Ctrl+B, then %            # Split pane vertically
# Ctrl+B, then "            # Split pane horizontally
# Ctrl+B, then arrow keys   # Switch between panes

Sempre rode tarefas de treinamento de longa duração dentro do tmux. Sempre.

WSL2 para Usuários do Windows

Se você está no Windows, o WSL2 te dá um ambiente Linux real sem dual-boot.

# In PowerShell (admin)
wsl --install -d Ubuntu-24.04

# After restart, open Ubuntu from Start menu
sudo apt update && sudo apt upgrade -y

O WSL2 roda um kernel Linux real. Tudo nesta lição funciona dentro dele. Seus arquivos do Windows ficam em /mnt/c/Users/YourName/ de dentro do WSL.

O repasse de GPU (passthrough) funciona com os drivers NVIDIA instalados no lado do Windows. Instale o driver NVIDIA do Windows (não o do Linux), e o CUDA estará disponível dentro do WSL2.

Pegadinhas: do macOS para o Linux

Coisas que vão te confundir se você vem do macOS:

Cartão de Referência Rápida

Navigation:     pwd, ls, cd, find
Files:          cp, mv, rm, mkdir, cat, head, tail, less
Search:         grep, find
Permissions:    chmod, chown, sudo
Packages:       apt update, apt install
Processes:      htop, ps, kill, nvidia-smi
Services:       systemctl start/stop/restart/status
Disk:           df -h, du -sh
Network:        curl, wget, scp, rsync
Sessions:       tmux new/attach/detach

Exercícios

1. Conecte via SSH a qualquer máquina Linux (ou abra o WSL2) e navegue até o seu diretório home. Crie uma pasta de projeto, crie três arquivos vazios dentro dela com touch e depois liste-os com ls -la.
2. Instale o htop com o apt, execute-o e identifique qual processo está usando mais memória.
3. Inicie uma sessão tmux, rode sleep 300 dentro dela, desanexe, liste as sessões e reanexe.
4. Use df -h para verificar o espaço em disco disponível, depois use du -sh ~/.cache/* para descobrir o que está ocupando espaço no seu cache.
5. Transfira um arquivo da sua máquina local para uma remota usando scp, depois faça a mesma transferência com rsync e compare a experiência.