Go Academy · Aula

Pacotes internos e workspaces

internal/, diretivas replace e go work

Pacotes internos e workspaces é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O diretório internal/

Os pacotes dentro de um diretório internal/ só podem ser importados por código na árvore de diretórios pai. Isso impõe o encapsulamento dos pacotes:

// Project structure:
// myapp/
//   main.go
//   internal/
//     auth/auth.go      <- can only be imported by myapp/
//     db/db.go          <- can only be imported by myapp/
//   api/
//     handlers.go       <- can import myapp/internal/auth

// External package CANNOT do:
// import "myapp/internal/auth"  <- compile error

Utilizando pacotes internal/

O código dentro do mesmo módulo (acima do diretório internal/) pode importar livremente os pacotes internos:

// myapp/api/handlers.go
package api

import (
    "myapp/internal/auth"
    "myapp/internal/db"
)

func GetUser(id int) (*db.User, error) {
    if !auth.IsValid() {
        return nil, auth.ErrUnauthorized
    }
    return db.FindUser(id)
}

Por que utilizar internal/?

Benefícios da convenção internal/:

Impede que outros módulos dependam de detalhes de implementação
Permite refatorar livremente sem quebrar os chamadores externos
Deixa claro que isso não faz parte da API pública
As ferramentas padrão do Go impõem a restrição no momento da compilação

Espaços de trabalho Go — go work

O Go 1.18 introduziu os espaços de trabalho para trabalhar simultaneamente com vários módulos locais, sem diretivas replace:

# Create a workspace in parent directory:
go work init ./myapp ./mylib

# Creates go.work:
# go 1.21
# use (
#     ./myapp
#     ./mylib
# )

# Now myapp can import mylib without replace directives

go work sync

Sincronize as dependências do espaço de trabalho com go work sync:

# go.work file:
go 1.21

use (
    ./api
    ./worker
    ./shared
)

# Sync all module dependencies:
go work sync

# Build across all workspace modules:
go build ./...

# Test across all workspace modules:
go test ./...

Espaço de trabalho versus diretiva replace

Comparação de duas abordagens para o desenvolvimento local com vários módulos:

// BEFORE workspaces (cumbersome):
// go.mod in myapp:
// replace github.com/me/mylib => ../mylib
// Must remove before publishing!

// WITH workspaces (cleaner):
// go.work at root:
// use (./myapp ./mylib)
// go.mod files stay clean — go.work is gitignored

Casos de uso dos espaços de trabalho

Quando utilizar espaços de trabalho Go:

Desenvolver uma biblioteca e seu consumidor simultaneamente
Trabalhar em um monorrepositório com vários módulos que fazem referência uns aos outros
Testar alterações em um módulo compartilhado antes de publicá-lo
Trabalhar em uma ramificação de uma dependência junto com seu aplicativo

go work add e go work use

Gerencie as entradas do espaço de trabalho com os subcomandos de go work:

# Add a module to the workspace
go work use ./newservice

# Remove a module from workspace
go work use -r ./oldservice

# Edit go.work directly (opens $EDITOR):
go work edit

# go.work should usually be gitignored:
echo "go.work" >> .gitignore
echo "go.work.sum" >> .gitignore

Internal + espaço de trabalho em conjunto

Pacotes internos e espaços de trabalho combinam naturalmente em monorrepositórios:

// Monorepo structure:
// services/
//   go.work
//   auth-service/
//     internal/tokens/   <- private to auth-service
//   order-service/
//     internal/pricing/  <- private to order-service
//   shared/
//     models/            <- shared across services

// go.work:
// use (./auth-service ./order-service ./shared)

Práticas recomendadas para organizar pacotes

Recomendações para a organização de projetos Go:

Estrutura de pacotes plana para projetos pequenos — evite organizar prematuramente
Utilize internal/ para detalhes de implementação que não se destinam ao uso externo
Coloque os pacotes main da CLI em cmd/appname/
Utilize espaços de trabalho para repositórios com vários módulos, mas adicione go.work ao gitignore
Evite aninhamentos profundos — no máximo 3 a 4 níveis de pacotes

Verificação rápida

Quem pode importar um pacote em um diretório internal/?

Recapitulação: pacotes internos e espaços de trabalho

Resumo:

internal/ restringe as importações à árvore de diretórios pai — isso é imposto pelo compilador
Utilize internal/ para ocultar detalhes de implementação de consumidores externos
go work init cria um espaço de trabalho para o desenvolvimento local com vários módulos
Os espaços de trabalho substituem as diretivas replace no desenvolvimento local
Adicione go.work e go.work.sum ao gitignore

Perguntas Frequentes

A aula “Pacotes internos e workspaces” é grátis?

Sim — o texto completo de “Pacotes internos e workspaces” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Pacotes internos e workspaces”?

internal/, diretivas replace e go work Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Pacotes internos e workspaces”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy