Noções Básicas da CLI do Linux

10 exemplos para você começar com a CLI do Linux para engenheiros Go - 7 básicos e 3 intermediários.

Pré-requisitos

• Um shell Linux (Linux nativo, WSL2 ou Terminal macOS para a maioria dos exemplos).
• Go 1.26.x ou posterior instalado e no seu PATH (go version).
• Um módulo de exemplo: mkdir goshell && cd goshell && go mod init example.com/goshell.
• Opcional: acesso sudo se você tentar o exemplo journalctl em um host systemd.

Exemplos Básicos

1. Encontre a Raiz do Seu Módulo

pwd imprime o diretório de trabalho; combine com ls para confirmar a presença de go.mod.

pwd
ls -la go.mod

• Execute comandos a partir da raiz do módulo para que go test ./... resolva os pacotes corretamente.
• ls -la mostra arquivos ocultos como .env que ferramentas como direnv podem carregar.
• A conclusão automática de nomes de diretórios reduz erros de digitação em caminhos longos de monorepositório.

Relacionado: Go Toolchain no Linux: Instalação e Troca de Versão - PATH e layout da toolchain

2. Liste Pacotes e Binários

tree (ou find) mostra a estrutura antes de executar testes amplos.

# instale tree se estiver faltando: sudo apt install tree
tree -L 2 -I vendor
go build -o bin/api ./cmd/api 2>/dev/null || echo "ajuste ./cmd/api para seu layout"
ls -lh bin/

• -L 2 limita a profundidade para que repositórios enormes permaneçam legíveis.
• -I vendor ignora árvores fornecidas durante uma orientação rápida.
• go build -o coloca artefatos em um diretório bin/ previsível para COPY do systemd ou docker.

Relacionado: Compile, Teste e Perfis a Partir do Shell - loops de compilação e teste

3. Localize um Símbolo com ripgrep

Pesquise Go source mais rápido que grep recursivo.

# instale: sudo apt install ripgrep  # ou brew install ripgrep
rg -n "func main" --glob '*.go'
rg -n "ListenAndServe" cmd/ internal/

• -n imprime números de linha para saltos rápidos no editor.
• --glob '*.go' ignora ruído de markdown e YAML.
• ripgrep respeita .gitignore por padrão, ignorando vendor/ quando ignorado.

Relacionado: Pesquisa, ripgrep e jq para Depuração - padrões de pesquisa avançados

4. Monitore Logs de Aplicação

Siga logs em tempo real enquanto você exercita um endpoint.

# app escrevendo em um arquivo
touch app.log
tail -f app.log
 
# outro terminal: curl -s localhost:8080/healthz >> app.log

• tail -f bloqueia até que novas linhas cheguem - ideal enquanto reproduz um bug.
• Prefira logs JSON estruturados para que uma passagem posterior de jq possa filtrar por nível.
• Rotacione arquivos grandes com logrotate ou limites de volume em contêineres.

Relacionado: Pesquisa, ripgrep e jq para Depuração - jq em logs JSON

5. Inspecione um Processo Go em Execução

Encontre o PID e qual porta ele detém.

pgrep -a api          # substitua 'api' pelo nome do seu binário
PID=$(pgrep -n api)
ps -p "$PID" -o pid,cmd,%cpu,%mem,etime
ss -ltnp | grep "$PID"    # ou: lsof -Pan -p "$PID" -i

• pgrep -a mostra a linha de comando - confirma que você se conectou ao binário correto.
• ss -ltnp mapeia sockets para PIDs no Linux moderno (netstat é legado).
• Corresponda ao nome do binário que você definiu com go build -o api.

Relacionado: systemd e Arquivos de Unidade de Serviço para Binários Go - processos supervisionados

6. Envie Sinais de Desligamento Gracioso e Forçado

Pratique SIGTERM antes de usar kill -9.

PID=$(pgrep -n api)
kill -TERM "$PID"     # o mesmo sinal que systemd stop usa primeiro
sleep 2
kill -0 "$PID" 2>/dev/null && echo "ainda em execução" || echo "encerrado"
# último recurso apenas:
# kill -KILL "$PID"

• Servidores Go devem capturar SIGTERM e chamar http.Server.Shutdown.
• kill -0 verifica a existência sem enviar um sinal.
• SIGKILL não pode ser capturado - use apenas quando o desligamento gracioso travar.

Relacionado: Habilidades da CLI do Linux para Engenheiros Go - sinais e operações

7. Exporte Variáveis de Ambiente de Compilação

Compile cruzado do shell sem editar o código.

export GOOS=linux GOARCH=amd64 CGO_ENABLED=0
go build -o dist/api-linux-amd64 ./cmd/api
file dist/api-linux-amd64
unset GOOS GOARCH

• CGO_ENABLED=0 produz um binário estático amigável para imagens de contêiner mínimas.
• file confirma ELF vs Mach-O para que você não envie o artefato errado.
• Redefina as variáveis após a compilação para que go test local use sua plataforma nativa.

Relacionado: Go Toolchain no Linux: Instalação e Troca de Versão - GOTOOLCHAIN e versões

Exemplos Intermediários

8. Leia o Journal systemd para um Serviço

Correlacione reinicializações de serviço com mensagens do kernel ou OOM.

sudo systemctl status api.service
sudo journalctl -u api.service -n 100 --no-pager
sudo journalctl -u api.service -f

• -u filtra por nome da unidade - corresponda ao seu arquivo .service.
• -n 100 limita a saída inicial antes do modo de acompanhamento.
• Os carimbos de data/hora do Journal ajudam a alinhar pilhas de pânico Go com eventos de implantação.

Relacionado: systemd e Arquivos de Unidade de Serviço para Binários Go - arquivos de unidade

9. Filtre Logs JSON com jq

Conte linhas de nível de erro e amostre um campo de stack trace.

cat app.json.log | jq -c 'select(.level=="ERROR")' | head
cat app.json.log | jq -s 'map(select(.level=="ERROR")) | length'

• -c imprime um objeto JSON compacto por linha para processamento posterior.
• -s carrega o arquivo em um array para agregações (bom para arquivos modestos).
• Para logs enormes, use rg '"level":"ERROR"' primeiro, depois jq no subconjunto.

Relacionado: Pesquisa, ripgrep e jq para Depuração - receitas de jq

10. Envie a Saída de Teste para um Arquivo e Pesquise Falhas

Capture a saída semelhante a CI localmente, depois pesquise falhas com ripgrep.

go test ./... -count=1 2>&1 | tee test.out
rg -n "FAIL:|panic:" test.out
rg -n "--- FAIL:" test.out -A 3

• 2>&1 mescla stderr em stdout para que os panics não sejam perdidos.
• -count=1 desabilita o cache de teste quando você precisa de um sinal fresco.
• tee mantém um arquivo para relatórios de bugs enquanto você observa o terminal.

Relacionado: Compile, Teste e Perfis a Partir do Shell - loops de teste e perfil

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - verifique o patch na compilação), chi (mais recente - verifique na compilação), gin (mais recente - verifique na compilação), echo (mais recente - verifique na compilação), google.golang.org/grpc (mais recente - verifique na compilação), sigs.k8s.io/controller-runtime (mais recente - verifique na compilação), kubebuilder (mais recente - verifique na compilação), tinygo (mais recente - verifique os alvos de placa na compilação), wazero (mais recente - verifique na compilação) e golangci-lint (mais recente - verifique o conjunto de linters na compilação).