Go Academy · Aula

Alternativas: HashiCorp go-plugin

Plugins baseados em RPC para suporte multiplataforma

Alternativas: HashiCorp go-plugin é 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.

Por que usar go-plugin?

O pacote nativo de plug-ins do Go funciona apenas no Linux/macOS, exige versões idênticas das dependências e não permite descarregar plug-ins. O go-plugin da HashiCorp resolve esses problemas executando os plug-ins como processos separados que se comunicam por RPC (gRPC ou net/rpc).

Arquitetura

O go-plugin executa o binário do plug-in como um subprocesso. O programa hospedeiro o inicia, estabelece uma conexão gRPC/net/rpc e chama o plug-in por meio de um cliente gerado. O processo do plug-in é encerrado quando o programa hospedeiro termina.

Definindo a interface

Defina a interface em um pacote compartilhado e forneça uma ponte gRPC ou net/rpc.

// shared/interface.go
type Greeter interface {
    Greet(name string) (string, error)
}

Lado do plug-in

O plug-in implementa a interface e a registra com o mecanismo Serve do go-plugin:

func main() {
    plugin.Serve(&plugin.ServeConfig{
        HandshakeConfig: Handshake,
        Plugins: map[string]plugin.Plugin{
            "greeter": &GreeterPlugin{Impl: &Greeter{}},
        },
        GRPCServer: plugin.DefaultGRPCServer,
    })
}

Lado do programa hospedeiro

O programa hospedeiro inicia o subprocesso do plug-in e obtém a interface por meio de um cliente:

client := plugin.NewClient(&plugin.ClientConfig{
    HandshakeConfig: Handshake,
    Plugins:         PluginMap,
    Cmd:             exec.Command("./greeter-plugin"),
    AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},
})
rpcClient, _ := client.Client()
raw, _ := rpcClient.Dispense("greeter")
greeter := raw.(Greeter)

Configuração do Handshake

Uma HandshakeConfig compartilhada (chave + valor de cookie mágico) impede que um binário que não seja um plug-in seja iniciado acidentalmente como plug-in:

var Handshake = plugin.HandshakeConfig{
    ProtocolVersion:  1,
    MagicCookieKey:   "GREETER_PLUGIN",
    MagicCookieValue: "hello",
}

Entre plataformas

Como o plug-in é um processo separado que se comunica por TCP ou por um soquete Unix, ele pode ser compilado para qualquer plataforma. O programa hospedeiro e o plug-in não precisam usar versões idênticas do Go.

Isolamento de falhas

Se um plug-in falhar, o programa hospedeiro receberá um erro na próxima chamada RPC. O programa hospedeiro poderá reiniciar o subprocesso do plug-in e restabelecer a conexão sem falhar também.

Desempenho

O RPC do go-plugin adiciona latência em comparação com chamadas de funções no mesmo processo (microssegundos contra nanossegundos). É aceitável para chamadas de plug-ins pesadas e pouco frequentes, mas não é adequado para laços críticos.

Versionamento

O go-plugin oferece versionamento de protocolo — o programa hospedeiro pode negociar simultaneamente com várias versões de uma interface de plug-in, permitindo atualizações graduais dos plug-ins.

Uso no mundo real

O go-plugin é usado nos provedores do Terraform, nos mecanismos de segredos do Vault e nos construtores do Packer da HashiCorp — grandes ecossistemas com plug-ins desenvolvidos pela comunidade.

Quando escolher

Escolha go-plugin em vez de plug-ins nativos quando: for necessário suporte entre plataformas, o isolamento de falhas for importante, não for possível alinhar as versões das dependências ou os plug-ins forem escritos por terceiros.

Verificação rápida

Como o go-plugin da HashiCorp obtém isolamento de falhas?

Recapitulação: HashiCorp go-plugin

Pontos principais:

Os plug-ins são executados como subprocessos; comunicam-se por gRPC ou net/rpc
Entre plataformas, com isolamento de falhas e tolerância a versões
HandshakeConfig impede a inicialização acidental de um binário
Há sobrecarga de desempenho causada pelo RPC; use para chamadas pesadas e pouco frequentes

Perguntas Frequentes

A aula “Alternativas: HashiCorp go-plugin” é grátis?

Sim — o texto completo de “Alternativas: HashiCorp go-plugin” é 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 “Alternativas: HashiCorp go-plugin”?

Plugins baseados em RPC para suporte multiplataforma 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 “Alternativas: HashiCorp go-plugin”?

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