Noções Básicas de Integração de Equipe

9 exemplos para você começar com Equipe e Integração - 7 básicos e 2 intermediários.

Pré-requisitos

• Instale o Go 1.26.x ou posterior em go.dev/dl.
• Clone o repositório da sua equipe e confirme se go version corresponde à versão na CI (verifique .github/workflows ou Makefile).
• Instale golangci-lint se o seu repositório o documentar; verifique a versão em relação aos padrões da equipe.
• Tenha credenciais SSH ou HTTPS para o GitHub (ou seu forge) e acesso ao canal Slack ou de chat da equipe.

Exemplos Básicos

1. Verifique a toolchain e o módulo

Confirme o Go e os metadados do módulo antes de tocar no código do aplicativo.

// Execute na raiz do repositório após clonar:
// go version
// go mod download
// go env GOMOD GOPATH

go version
go mod download
go env GOMOD

• go mod download baixa os módulos listados em go.mod sem compilar.
• GOMOD mostra o caminho do arquivo do módulo ativo; vazio significa que você está fora de um módulo.
• A CI geralmente fixa uma tag de imagem Go - combine-a localmente para evitar desvios de "funciona na minha máquina".

Relacionado: Integração de Especialistas Go - caminhos de ramp-up para contratados experientes

2. Execute a suíte de testes local completa

Testes verdes são a prova básica de que seu laptop corresponde ao ambiente da equipe.

go test ./...

• ./... recursa todos os pacotes sob o módulo atual.
• Adicione -race quando sua equipe o exigir para pacotes de concorrência.
• Uma falha na clonagem geralmente significa variáveis de ambiente ausentes documentadas no README.

Relacionado: Checklist de Integração de Especialistas Go (30/60/90) - expectativas de teste para o dia 30

3. Formate e verifique antes do primeiro commit

Automatize o que os revisores pedirão de qualquer maneira.

gofmt -w .
go vet ./...

• gofmt é o único formatador oficial; código não formatado não deve ser mesclado.
• go vet sinaliza construções suspeitas; muitas equipes o executam na CI.
• Combine com golangci-lint run quando o repositório distribuir um .golangci.yml.

Relacionado: Cultura de Revisão de Código para Go - o que os revisores esperam em cada PR

4. Encontre a entrada do pacote e o principal

Aprenda onde os binários começam e como os pacotes se conectam.

go list -f '{{.ImportPath}}' ./...
grep -r "func main" cmd/ 2>/dev/null || grep -r "func main" .

• A maioria dos serviços usa o layout cmd/<binary>/main.go.
• go list mostra os caminhos de importação que seu módulo possui.
• Saber a localização de main ajuda você a rastrear a fiação no primeiro dia.

Relacionado: Caminho de Leitura Eficaz de Go - ordem de estudo após a orientação do repositório

5. Leia a documentação do pacote localmente

Visualize o godoc da maneira que os revisores esperam que as APIs exportadas leiam.

go doc ./internal/config
go doc -all ./...

• Comentários em símbolos exportados devem começar com o nome do símbolo.
• go doc é mais rápido do que vasculhar arquivos ao explorar pacotes desconhecidos.
• Observe os pacotes que não têm documentação; melhorá-los é um bom primeiro PR.

Relacionado: Convenções de Documentação e godoc - padrões de comentários da equipe

6. Execute o alvo Make ou script equivalente à CI

Reproduza as etapas do pipeline localmente antes de enviar.

make test
# ou
./scripts/ci.sh

• As equipes agrupam go test, lint e build atrás de make para consistência.
• Leia o Makefile ou o YAML do fluxo de trabalho para ver quais sinalizadores a CI adiciona (limites de corrida, cobertura).
• Corrigir uma etapa vermelha da CI localmente economiza idas e vindas de revisão.

Relacionado: Integração de Especialistas Go - por que a paridade da CI é importante na primeira semana

7. Abra um pequeno primeiro PR

Mescle algo de baixo risco para aprender o fluxo de trabalho de revisão.

Típicos primeiros PRs: corrigir um erro de digitação no README, adicionar uma frase de godoc ausente ou estender um teste baseado em tabela.

git checkout -b onboarding/first-pr
# edite os arquivos
go test ./...
git commit -m "docs: esclarecer etapas de configuração local"
git push -u origin HEAD

• Mantenha o escopo minúsculo para que o feedback se concentre no processo, não na arquitetura.
• Responda aos comentários de revisão com commits ou trade-offs explicados.
• Vincule o PR em seu checklist de 30/60/90 quando mesclado.

Relacionado: Sessões de Emparelhamento e Mob para Equipes Go - emparelhamento opcional antes do primeiro push

Exemplos Intermediários

8. Rastreie um manipulador com contexto e erros

Siga um caminho de solicitação para ver o uso idiomático de erros e contexto em sua base de código.

func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    if err := s.db.Ping(ctx); err != nil {
        http.Error(w, "unavailable", http.StatusServiceUnavailable)
        return
    }
    w.WriteHeader(http.StatusOK)
}

• r.Context() carrega prazos e cancelamento do servidor.
• Manipuladores mapeiam erros para status HTTP na borda; bibliotecas retornam error.
• Use grep para manipuladores semelhantes para aprender padrões de nomenclatura e middleware.

Relacionado: Caminho de Leitura Eficaz de Go - seções de concorrência e HTTP a seguir

9. Agende uma sessão de emparelhamento com agenda

Emparelhamento estruturado supera o compartilhamento de tela ad hoc para aprendizado na primeira semana.

Modelo de agenda:

1. Percorra o layout do módulo e os binários cmd/ (15 min).
2. Revisão ao vivo de um PR exemplar mesclado (20 min).
3. Emparelhe em uma execução de teste -race ou correção de linter (25 min).

• Registre notas na wiki da equipe ou no ticket de integração.
• Alterne os parceiros mensalmente para absorver múltiplas vozes de revisão.
• Traga uma pergunta concreta (erros, interfaces ou testes) para cada sessão.

Relacionado: Sessões de Emparelhamento e Mob para Equipes Go - formatos de mob e exercícios de concorrência

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, modernizadores go fix - 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).