Melhores Práticas da CLI do Linux

Orientação compartilhada e portátil para engenheiros Go que operam serviços em hosts Linux, em CI e dentro de contêineres.

Aplique estas regras em runbooks, listas de verificação de onboarding e revisões de código quando os fluxos de trabalho do shell tocarem em caminhos de produção.

Como Usar Esta Lista

• Marque os itens à medida que sua equipe padroniza laptops, imagens de CI e runbooks.
• Trate as regras da Categoria A como obrigatórias antes do acesso SSH ou kubectl à produção.
• Codifique hábitos de teste e captura de logs em scripts de CI, não em conhecimento tribal.
• Revise quando adotar imagens distroless, novas versões do toolchain Go ou implantações apenas GitOps.

A - Navegação e ambiente

• Inicie comandos da raiz do módulo com go.mod visível. Diretórios de trabalho incorretos produzem erros confusos de go test e de configuração relativa.
• Mantenha GOPATH/bin e GOROOT/bin no PATH em shells de login e não-login. Caso contrário, CI e trabalhos cron não encontrarão as ferramentas go install.
• Defina explicitamente a política GOTOOLCHAIN (auto vs local). Versões reproduzíveis não devem surpreender com downloads no meio do pipeline.
• Escopo GOPRIVATE com direnv, não com .bashrc global. Evita vazar configurações de módulos da organização para repositórios pessoais.
• Documente a arquitetura ao compilar cruzado (GOOS, GOARCH, CGO_ENABLED). Envie o binário ELF que seu servidor realmente executa.

B - Processo e sinais

• Prefira SIGTERM e desligamento gracioso antes de kill -9. Valida os caminhos de Shutdown do Go nos quais você confia em systemd e Kubernetes.
• Identifique processos com pgrep/ss antes de reiniciar serviços. Evite matar o binário errado em hosts compartilhados.
• Defina LimitNOFILE (ou ulimits) para servidores Go com muitas conexões. O padrão de 1024 esgota sob concorrência HTTP moderada.
• Alinhe TimeoutStopSec do systemd com os tempos limite de desligamento no processo. Evita SIGKILL durante o esvaziamento de requisições.
• Execute comandos de longa duração sob tmux em hosts SSH. Conexões perdidas não devem abortar a coleta de evidências de go test ./....

C - Logs e busca

• Registre em stdout/stderr em contêineres e serviços supervisionados. As plataformas enviam logs do journal/kubelet, não arquivos dentro de discos efêmeros.
• Use nomes de campos JSON estáveis o suficiente para filtros jq. trace_id, level e msg não devem ser renomeados por versão sem aviso.
• Busque código com os padrões do ripgrep, não com grep -R sem escopo. Respeite .gitignore para pular vendor/ e artefatos de compilação.
• Capture a saída do comando com tee durante incidentes. Apenas pipes perdem evidências quando o scrollback é truncado.
• Correlacione logs de aplicativos com janelas journalctl --since. Linhas de OOM do kernel e reinícios de unidade explicam saídas silenciosas do processo Go.

D - Compilação, teste e perfil

• Execute go test ./... -count=1 antes de enviar quando a CI fizer o mesmo. O cache esconde falhas intermitentes localmente.
• Habilite -race na CI para pacotes Go puros, a menos que documentado de outra forma. Corridas de dados são mais baratas de corrigir antes da produção.
• Armazene perfis e logs de teste em artifacts/ com timestamps. Suporta postmortems e comparações de desempenho (pprof -base).
• Vincule o pprof de depuração apenas ao loopback ou port-forward. Abrir :6060 em 0.0.0.0 é uma exposição conhecida.
• Faça o perfil sob carga representativa, não em servidores ociosos. Perfis de CPU vazios desperdiçam tempo em incidentes.

E - systemd e VMs

• Execute serviços como usuários dedicados não-root. O Go não requer root, exceto em casos especiais de bind - use proxies ou capacidades.
• Mantenha segredos fora de arquivos de unidade legíveis por qualquer pessoa. Use EnvironmentFile restrito ou agentes de segredo.
• Use Restart=on-failure com backoff RestartSec. Loops de falha não devem sobrecarregar bancos de dados na inicialização.
• Versionar binários em /opt/<app>/bin com trocas atômicas de symlink. Suporta rollback sem editar arquivos de unidade.
• Teste ExecStart manualmente como o usuário do serviço antes de habilitar. Captura erros de permissão e caminho precocemente.

F - Contêineres e Kubernetes

• Use Dockerfiles multi-estágio: compile com a imagem Go, execute o runtime mínimo. Imagens distroless ou estáticas reduzem a superfície de ataque.
• Adicione .dockerignore excluindo .git, testes e artefatos locais. O tamanho da imagem e a rotação do cache permanecem previsíveis.
• Verifique kubectl describe Events para sondas e códigos de saída. Logs sozinhos não capturam as causas raiz de CrashLoopBackOff.
• Use kubectl logs --previous após falhas. Logs do contêiner atual podem estar vazios em falhas instantâneas.
• Feche kubectl port-forward após a depuração. Túneis ignoram a política que você assume proteger as portas de administração.

G - Produtividade e segurança

• Permita direnv apenas após revisar diffs de .envrc. Evita injeção maliciosa de ambiente em clones compartilhados.
• Evite colar credenciais de produção no histórico do shell. Prefira scripts que leem de arquivos de cofre ou env injetado em tempo de execução.
• Fixe versões de ferramentas em runbooks (kubectl, docker, jq). Diferenças de flags da CLI quebram o copiar e colar durante incidentes.
• Prefira scripts reproduzíveis em vez de comandos heroicos únicos. Postmortems devem reproduzir passos exatos.
• Redija PII antes de compartilhar trechos de log em tickets. Extrações com jq não são anonimização automática.

FAQs

Relacionados

• Habilidades da CLI do Linux para Engenheiros Go - visão geral da seção
• Noções Básicas da CLI do Linux - exemplos práticos iniciais
• Compilar, Testar e Perfil a partir do Shell - fluxos de trabalho de teste e pprof
• systemd e Arquivos de Unidade de Serviço para Binários Go - unidades de produção
• Contêineres a partir da CLI: docker & kubectl - depuração de cluster
• Produtividade do Shell: tmux, fzf & direnv - fluxo de trabalho do terminal

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