Gerenciamento de dependências no Go

Durante o desenvolvimento de software é comum nos depararmos com certos problemas comuns, como, por exemplo, realizar a validação de um CPF, realizar requisições HTTP, conectar em um banco de dados, entre outras situações.

Porém, não seria muito produtivo termos que implementar essas funcionalidades manualmente sempre que forem necessárias, por isso, na maioria das linguagens temos a possibilidade de usarmos pacotes feitos pela própria comunidade que resolvem esses problemas e para facilitar ainda mais no processo de gerenciamento desses pacotes, nós podemos utilizar ferramentas comumente chamadas de gerenciador de dependências?

Curso Lógica de Programação - Iniciando na programação

Conhecer o curso

O que é um gerenciador de dependências?

Um gerenciador de dependências é uma ferramenta que ajuda a gerenciar as bibliotecas e pacotes que um projeto precisa para funcionar corretamente. Ele permite que as dependências sejam facilmente instaladas, atualizadas e removidas, sem a necessidade de gerenciá-las manualmente.

Isso pode economizar muito tempo e evitar erros de compatibilidade entre diferentes versões de bibliotecas. Em Go, o gerenciador de dependências padrão é o Go Modules (Módulos Go), que é uma ferramenta integrada ao Go e facilita muito o processo de gerenciamento de dependências.

Gerenciando dependências no Go

Curso Lógica de Programação - Avançando na programação

Conhecer o curso

A partir da versão 1.11, passamos a utilizar o recurso chamado de Go Modules para realizar o gerenciamento de dependências no Go. Antes era necessário realizar todo o processo de gerenciamento de dependências de maneira manual, ou, mediante ferramentas desenvolvidas pela comunidade, como, por exemplo, a ferramenta dep.

Iniciando um módulo

Primeiramente, para podermos realizar as ferramentas de gerenciamentos de dependências em projetos Go, precisamos inicializar um módulo em nosso projeto. Para isso executamos o seguinte comando:

go mod init nome-do-modulo

Ao executar o comando acima iremos transformar o nosso projeto em um módulo Go, o que habilita a possibilidade de utilizarmos o gerenciamento de dependências. O idela é que o nome do módulo seja um nome único e por isso é comum usarmos o caminho completo para um repositorio de algum sistema de controle de versão, como, por exemplo, o GitHub.

go mod init github.com/treinaweb/meu-projeto-go

Quando o comando go mod init é executado, serão criados dois arquivos na raiz do projeto, são eles:

• go.mod: este arquivo é responsável por descrever todas as dependências do projeto e suas respectivas versões.
• go.sum: este arquivo é responsável por armazenar um hash de cada dependência do projeto, garantindo que as dependências sejam baixadas de forma segura e confiável.

Como encontrar um pacote para usar?

Curso Clean Code e SOLID - Escrevendo código limpo e escalável

Conhecer o curso

Para encontrar um pacote para usar em um projeto Go, podemos pesquisar em repositórios públicos como o GitHub ou o pkg.go.dev. O pkg.go.dev é uma ferramenta específica para a documentação de pacotes e bibliotecas em Go, e pode ser uma fonte útil para encontrar pacotes relacionados a uma funcionalidade específica.

Ao clicar em algum dos pacotes encontrados, será exibido uma página com todas as informações do pacote (como instalar, documentação, versões e etc).

Como instalar um pacote no projeto?

Agora que já sabemos como iniciar um módulo para podermos ativar o gerenciamento de dependências em projetos Go e também sabemos como encontrar pacotes úteis para uso. Precisamos saber como adicionar esses pacotes como dependências de nosso projeto.

Para isso, basta executar o comando go get seguido do identificador do pacote desejado, para sabermos o identificador do pacote basta o nome do repositório do pacote desejado, no exemplo de pesquisa do tópico anterior o identificador do pacote é github.com/google/uuid, então o comando completo fica:

go get github.com/google/uuid

Ao executarmos o comando acima, o gerenciador de pacotes do Go irá buscar pelo repositório solicitado e então irá realizar o download da última versão disponível e também irá atualizar os arquivos go.mod e go.sum com as devidas informações dos pacotes baixados.

Se visualizarmos o conteúdo do aquivo go.mod veremos algo similar a isso:

module github.com/treinaweb/meu-projeto-go

go 1.20

require github.com/google/uuid v1.3.0 // indirect

Veja que, nesse arquivo temos o nome do nosso módulo, a versão da linguagem que estamos utilizando e por fim as dependências do projeto. Outro ponto importante de ser observado é que a nossa dependência está marcada como indirect, isso acontece, pois a dependência foi adicionada no projeto, porém, ainda não foi utilizada em nenhum lugar. O gerenciador de dependências do Go analisa os arquivos do código para verificar quais dependências de fato estão sendo utilizadas.

Como instalar uma versão específica?

Como vimos, ao realizar o comando go get é feito o download da versão mais recente do pacote solicitado, porém, também é possível realizar a instalação de uma verão especifica do pacote desejado.

Para instalar uma versão específica de um pacote, basta adicionar o sufixo @ seguido da versão desejada ao final do identificador do pacote no comando go get. Por exemplo, para instalar a versão 1.2.3 do pacote github.com/google/uuid, basta executar o seguinte comando:

go get github.com/google/uuid@v1.2.3

Dessa forma, o gerenciador de pacotes do Go irá baixar e instalar a versão especificada do pacote em questão.

Como atualizar as versões das dependências do projeto?

Para atualizar as versões de todos os pacotes listados no arquivo go.mod do projeto, basta executar o comando go get -u.

Como atualizar uma dependência específica?

Curso Go Básico

Conhecer o curso

Para atualizar uma dependência específica, basta executar o comando go get -u seguido do identificador do pacote e da versão desejada. Por exemplo, para atualizar o pacote github.com/google/uuid para a versão mais recente, basta executar o seguinte comando:

go get -u github.com/google/uuid

Ao executar o comando acima, o gerenciador de pacotes do Go irá baixar e instalar a versão atualizada do pacote em questão e também irá atualizar os arquivos go.mod e go.sum com as devidas informações das dependências atualizadas.

Como sincronizar as dependências do código?

Para sincronizar as dependências do código, basta executar o comando go mod tidy. Esse comando irá verificar quais dependências são usadas no código e irá adicionar ou remover as que são necessárias ou desnecessárias, respectivamente. Isso ajuda a manter o arquivo go.mod atualizado e consistente com o código atual.

Também podemos utilizar o comando go mod tidy para remover as dependências do projeto, para isso basta excluir a dependência indesejada do arquivo go.mod e então rodar o comando go mod tidy.

Conclusão

Gerenciar dependências em projetos Go é uma tarefa essencial para manter a consistência e a estabilidade do código. Com o Go Modules, isso se tornou muito mais fácil e prático, permitindo que as dependências sejam facilmente instaladas, atualizadas e removidas. Além disso, é importante lembrar que a documentação oficial do Go e o pkg.go.dev podem ser bastante úteis na hora de encontrar pacotes e bibliotecas para utilizar em seus projetos.

Por fim, caso queira aprender mais sobre a Go e sua infinidade de recursos saiba que aqui na TreinaWeb temos o curso Go Básico que possui 05h30 de vídeo e um total de 37 exercícios.

Veja quais são os tópicos abordados durante o curso Go Básico:

• Compreender a sintaxe básica da Golang;
• Compreender conceitos básicos envolvidos na Go, como ponteiros de memória;
• Utilizar as estruturas básicas da linguagem, como declaração de variáveis;
• Utilizar as principais estruturas de conjuntos da Go, como arrays, slices e maps;
• Entender as principais funções na Golang que são built-in, como make(), new(), panic(), recover() e defer;
• Organizar o código em pacotes e utilizar os principais pacotes disponibilizados pela linguagem;
• Entender como podemos utilizar concorrência com a Golang, inclusive com técnicas como os channels;
• Entender o que são as structs na Go e como podemos utilizar um pouco de orientação a objetos com a linguagem;
• Realizar operações de I/O no sistema operacional, como a criação e escrita de arquivos.