Gerencie suas versões Go com GVM
Tags: go, gvm
Published: 2020-08-25 22:42:56

Ganhe produtividade gerenciando as versões Go na sua máquina de forma simples usando o GVM

## Introdução

A configuração de um ambiente de desenvolvimento Go pode ser um pouco confusa para quem está acostumado a trabalhar com outras linguagens. Quando estamos falando de versões do Go inferiores a 1.11, o cenário ainda pode se tornar mais chato devido suas peculiaridades (que não serão abordadas nesse momento, mas quem já precisou, sabe do que se trata).

Como de padrão no mundo Go, a [documentação oficial](https://golang.org/doc/install) traz uma solução que se mostra relativamente fácil, bem clara e objetiva; e que, inclusive, fala sobre a questão de ter mais de uma versão do Go instalada ao mesmo tempo.

veja mais sobre como configurar o seu ambiente na [Documentação Oficial Golang](https://golang.org/doc/install)

Mesmo assim, o gerenciamento é um trabalho manual que exige uma quantidade grande de passos e que tende a ficar mais complicada dependendo da quantidade de versões instaladas que você possui.
O chaveamento entre versões também pode ser um problema quando você possuir diferentes projetos no seu workspace que estejam em fases de maturidade diferentes. Se você tem projetos antigos em uma determinada versão, mas quer escrever um novo com uma versão mais atual, isso também pode ser um processo trabalhoso.
Pensando em diminuir essa complexidade e melhorar o gerenciamento de versões, surgiu o [GVM](https://github.com/moovweb/gvm).

Admito que me preocupo um pouco em escrever sobre uma ferramenta que não tem recebido commits recentes (enquanto escrevo esse texto, tem 1 ano desde o último commit), mas como ele ainda tem se mostrado uma ferramenta relativamente útil no meu dia-a-dia, prefiro apostar na recomendação.
Note que algumas outras linguagens já possuem ferramentas que fazem um trabalho similar. É o caso, por exemplo, do [NVM](https://github.com/nvm-sh/nvm) para o gerenciamento de versões Node.JS.

## Ambiente 

É importante frisar antes de mais nada que estamos fazendo todo esse processo em um ambiente Linux. Mais precisamente para esse exemplo estamos utilizando a Versão 18.04.2 LTS do Ubuntu, mas já fiz o mesmo procedimento em um ambiente MacOS e funciona tão bem quanto.

## Instalação 

Para instalar execute o seguinte comando de acordo com o seu interpretador shell.

- Bash 
```bash
$ bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
```

- ZSH 
```bash 
$ zsh < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
```

Esse comando irá gerar uma **.gvm** dentro da sua home. Mo meu caso, a pasta foi criada em **~/.gvm**

![Retorno no terminal que será exibido após executar o comando anterior](https://dev-to-uploads.s3.amazonaws.com/i/sqtuuj1uv09q5pnf51su.png)

Restarte o terminal e execute o comando `gvm version` para confirmar que a instalação foi efetuada com sucesso.
Eventualmente pode acontecer de algumas dependências não estarem instaladas. Por exemplo, no ambiente que estou usando como base para esse texto, ainda faltava instalar algumas dependências.

![Dependências faltando](https://dev-to-uploads.s3.amazonaws.com/i/zoq97c7mbr7aqmjhkgs0.png)

Com as dependências devidamente instaladas, executamos novamente o comando `gvm version` e teremos o seguinte retorno.

![Versão instalada](https://dev-to-uploads.s3.amazonaws.com/i/nf1cq4s2yzgocmcn158t.png)

Note que para que o comando gvm seja identificado pelo Sistema Operacional, uma nova linha foi adicionada dentro do seu arquivo **bashrc**.

## Instalando Go
Agora vamos efetivamente instalar as versões que queremos ter como opções no nosso ambiente. Nesse caso, vamos instalar as versões 1.10 e a 1.11, sendo a última como nossa versão padrão. Para isso, basta executar os seguintes comandos:

```bash 
$ gvm install go1.10 -B
$ gvm install go1.11 -B
```

Para a versão 1.11 como padrão, execute:

```bash 
$ gvm use go1.11 --default 
```

Para validar, liste as versões instaladas por meio do comando:

```bash 
$ gvm list
```

Você terá o seguinte retorno

![Versões instaladas do Go](https://dev-to-uploads.s3.amazonaws.com/i/656vtuwb7h82iiz5oc7p.png)

Feito isso já teremos nosso ambiente pronto para uso e as variáveis de ambiente **$GOROOT** e **$GOPATH** já foram configuradas automaticamente. Por padrão são definidos nos caminhos:

```bash
#GOPATH
~/.gvm/pkgsets/go1.11/global
#GOROOT
~/.gvm/gos/go1.11
```

## Validando 
Feito todo esse processo de instalação, a forma que usamos o Go no nosso ambiente não deve ser influenciada. Então vamos validar o que fizemos. Para isso, vamos criar um Hello.go com o seguinte código.

```go
package main

import "fmt"

func main() {
	fmt.Printf("hello, world\n")
}
```

E aí está…. verificamos que a versão instalada é a que selecionamos e também que nosso código foi executado com sucesso.

![Sucesso](https://dev-to-uploads.s3.amazonaws.com/i/01yw4r1ljwkr1fonv5lx.png)

## Conclusão
Mesmo a documentação mostrando que pode ser relativamente simples manter mais de uma versão instalada ao mesmo tempo de forma “nativa”, gastar tempo configurando ambiente é uma coisa que ninguém gosta e o GVM se mostra eficiente nesse aspecto. Instalar uma nova versão e chavear entre elas se mostra uma tarefa muito menos custosa usando esse gerenciador de versões. E você, o que achou? Deixe seu comentário e até a próxima.

---

Gostou do [GVM](https://github.com/moovweb/gvm).? Leia mais detalhes na documentação oficial no Github

{% github moovweb/gvm %}