GoLang: Comandos básicos para iniciar seu projeto

GoLang

Se você é novato na linguagem Go e não sabe como iniciar seu projeto ou se você vem de outra linguagem a qual tem um gerenciamento de módulos, é normal que se pergunte como funciona o gerenciamento de módulos do Go. Para isso vou tentar explicar o passo a passo de como iniciar um projeto Go do zero, assim mostrando os principais comandos. Boa parte desse tutorial foi baseado no vídeo criado pelo Alex Rios.

Antes de iniciarmos é obrigatório que você tenha o GoLang instalado em sua máquina. Você pode conferir na documentação oficial ou pode utilizar o GVM (Go Version Manager) para instalar a linguagem em sua máquina.

Iniciando

1- O primeiro passo é criar uma pasta onde iremos colocar os arquivos do mini-projeto. Irei criar com o nome go-project.

2- Agora crie um arquivo chamado main.go. Nesse arquivo iremos escrever as primeiras linhas de código Go.

3- Insira o seguinte código em seu arquivo main.go:

package main

import "log"


func main() {
	log.Printf("%d + %d = %d", 2, 2, add(2, 2))
}

func add (a, b int) int {
	return a + b
}

O que esse código faz é somar dois números inteiros e logar o seu resultado no console. Para rodar esse código basta executar o seguinte comando:

go run main.go

4- Agora o que iremos fazer é iniciar o nosso projeto Go com o comando abaixo:

go mod init github.com/user/myproject

Esse comando espera que você informe a URL do seu projeto, esta que pode ser alterada posteriormente.

Ao rodar o comando acima, será criado um arquivo chamado go.mod, este que terá informações de todos as dependências que existe em seu projeto e que devem ser instaladas para o mesmo poder rodar. Nele também terá a informação da versão do Go que seu projeto suporta e qual a URL onde o código está hospedado.

5- Agora iremos substituir o módulo log pelo zerolog. Para isso substitua o import "log" por import log "github.com/rs/zerolog/log". No final ficara assim:

package main

import log "github.com/rs/zerolog/log"


func main() {
	log.Printf("%d + %d = %d", 2, 2, add(2, 2))
}

func add (a, b int) int {
	return a + b
}

Se você executar o projeto agora, verá algo parecido com a imagem abaixo em seu terminal:

Perceba que o Go reconheceu o novo módulo e fez a instalação automaticamente. Ele também alterou o arquivo go.mod adicionando a seguinte linha:

require github.com/rs/zerolog v1.20.0

Na linha acima temos a URL do módulo e qual a versão que foi instalada. Você também pode rodar o comando go install, a diferença é que esse comando apenas irá instalar as dependência e não irá executar o projeto.

Obs.: sempre que os comandos go run, go test ou go build for executado, o Go irá instalar os módulos que ainda não foram instalados anteriormente.

Também podemos perceber que foi criado um arquivo denominado de go.sum. Esse arquivo guarda as hashs de todos as dependências diretas que o seu projeto depende e também as dependências indiretas. Isso garante que sempre que o projeto for executado do zero, os módulos sempre serão os mesmos a serem instalados, evitando assim problemas de incompatibilidade caso eles venham ser atualizados no futuro.

6- Agora iremos substituir o módulo de logs atual pelo módulo logrus. Para isso iremos substituir a linha de código import log "github.com/rs/zerolog/log" pelo código import log "github.com/sirupsen/logrus". Ao final ficará assim:

package main

import log "github.com/sirupsen/logrus"


func main() {
	log.Printf("%d + %d = %d", 2, 2, add(2, 2))
}

func add (a, b int) int {
	return a + b
}

Agora basta executar o projeto novamente para o Go poder instalar a nova dependência e adicioná-la ao arquivo go.mod.

Se olharmos nosso arquivo go.mod iremos perceber que temos duas dependências, o zerolog e o logrus. Podemos perceber que o zerolog não é mais utilizado em nosso projeto e com isso não há a necessidade dele estar listado no arquivo de módulos. Para resolver esse problema iremos executar o seguinte comando:

go mod tidy

O que esse comando faz é remover todos os módulos que não são utilizados em seu projeto e que estão listados no arquivo de módulos.


Até o momento conhecemos alguns comandos como go run, go install, go mod initgo mod tidy e também conhecemos como é feito o gerenciamento de dependências do Go. Logo abaixo iremos conhecer alguns outros comandos úteis no dia a dia de quem trabalha com GoLang.

7- Rodando testes unitários

No dia a dia quando estamos criando funcionalidades para o nosso projeto, é normal escrevermos códigos de teste para poder garantir as funcionalidades dos nossos códigos. Um comando muito útil para rodar nossos testes é o go test.

8- Listando pacotes, módulos e dependências:

- listar os pacotes e módulos do seu projeto: go list 
- listar o módulo atual e todas as suas dependências: go list -m all
- ver a versão instalada de um módulo/dependência: go list -m github.com/sirupsen/logrus
- listar a versão atual das dependências instalados e qual a última versão disponível: go list -u -m all

9- Adicionando ou atualizando dependências/módulos

Suponhamos que o módulo logrus está listado em nosso go.mod com a versão 1.7.0 e que a última versão dele seja a 1.8.0.

Para podermos atualizar ele para a última versão basta executar o comando go get github.com/sirupsen/logrus. Ao executar esse comando a última versão será instalada e o arquivo go.mod será atualizado com a última versão do módulo. Você também pode especificar uma versão ao executar o comando da seguinte forma go get github.com/sirupsen/logrus@v1.8.0

Se o módulo logrus não existisse no arquivo go.mod, o Go iria adicionar ele ao arquivo e iria instalá-lo.

Você pode também atualizar todas as dependências diretas e indiretas de uma vez só, com o comando go get -u .

10- Visualizando a documentação de módulos

Para poder visualizar a documentação de um módulo, existe um comando bem interessante, o go doc. Com ele é possível ver exemplos de como implementar o módulo no projeto e quais são as funções disponíveis por ele. Ex.: go doc github.com/sirupsen/logrus

11- Trabalhando com o diretório Vendor

Quando trabalhamos com vários projetos e esses projetos tem módulos iguais mais com versões diferentes e utilizam a mesma versão do Go, conseguimos separar cada versão dos módulos por projeto, assim não precisando instalar as versões dos módulos novamente toda vez que for executar o projeto. O vendor é um diretório virtual com as dependências que seu projeto precisa para rodar e que fica dentro do próprio projeto. Normalmente esse diretório não é enviado para o controle de versão do seu projeto.

Para criar o diretório vendor em seu projeto basta executar o comando go mod vendor

12- Compilando o projeto

Quando finalizamos nosso projeto é comum compilarmos o mesmo para poder disponibilizá-lo ao público. O comando básico para podermos compilar o projeto é o go build .

Não irei entrar em detalhes, mas basicamente ele irá gerar um executável de acordo com o SO que você está utilizando, este que poderá ser executado sem que o usuário tenha acesso ao código fonte do projeto.

Comentários

Postagens mais visitadas deste blog

pgAdmin 4: Configurando um server do Postgres

Oh My Zsh: Melhorando a produtividade do seu terminal

Git: Renomear, desfazer, mesclar, editar ou excluir commits