GOPATH e Go Modules

Introdução

Neste laboratório, vamos explorar as duas formas principais de gerenciar dependências no ecossistema Go: o tradicional GOPATH e os modernos Go Modules. Compreender esses conceitos é fundamental para organizar e manter seus projetos Go de maneira profissional e eficiente.

Pontos de Conhecimento:

GOPATH
GOROOT
Go Modules

Preparação

Nesta etapa, vamos configurar o ambiente de trabalho descompactando um arquivo compactado fornecido para o exercício.

Primeiro, abra o seu terminal e navegue até o diretório do projeto digitando o seguinte comando:
```
cd ~/project
```
Descompacte o arquivo helloWorld.tar.gz no diretório atual:
```
tar -xzf helloWorld.tar.gz
```
Após a extração, verifique se a pasta helloWorld foi criada com sucesso:
```
ls helloWorld
```

Isso listará o conteúdo do diretório helloWorld se a descompactação tiver ocorrido corretamente.

Conceitos Básicos do GOPATH

Antes da versão 1.11 do Go, a linguagem utilizava um espaço de trabalho específico chamado GOPATH para centralizar todo o código-fonte. Nesta etapa, entenderemos como essa estrutura funciona.

GOROOT é o diretório onde o Go está instalado no sistema, contendo as ferramentas da linguagem e os pacotes da biblioteca padrão.
GOPATH é o local onde reside o seu código pessoal e as bibliotecas de terceiros, sendo composto por três subdiretórios:
- src: Armazena o código-fonte dos seus projetos.
- bin: Armazena os arquivos executáveis compilados.
- pkg: Armazena pacotes compilados que não são executáveis (objetos de pacotes).

Para verificar as configurações atuais de GOPATH e GOROOT no seu ambiente, execute os seguintes comandos:

## Verificar o diretório GOPATH
go env | grep GOPATH

## Verificar o diretório GOROOT
go env | grep GOROOT

Esses comandos exibirão os caminhos configurados para GOPATH e GOROOT na sua máquina.

Inicializando um Módulo

Os Go Modules, introduzidos no Go 1.11 e habilitados por padrão a partir da versão 1.13, surgiram para resolver dois problemas críticos:

Dependência excessiva do GOPATH: Antes dos módulos, todo código precisava estar dentro de GOPATH/src. Com Go Modules, você pode organizar seus projetos em qualquer pasta do sistema.
Gestão de versões: Os módulos permitem que os projetos gerenciem e rastreiem dependências com versões específicas, facilitando o trabalho com diferentes versões de um mesmo pacote.

Nesta etapa, vamos inicializar um Go Module para um novo projeto.

Crie um novo diretório para o projeto chamado testHello:
```
cd ~/project
mkdir testHello
```
Entre no diretório testHello:
```
cd testHello
```
Inicialize o módulo Go para este projeto:
```
go mod init testHello
```
A saída esperada deve ser:
```
go: creating new go.mod: module testHello
```

Crie um novo arquivo Go chamado testHello.go dentro da pasta testHello com o seguinte conteúdo:

touch testHello.go

package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}

Agora, inicializamos o projeto testHello usando Go Modules e adicionamos um programa simples a ele.

Importando Pacotes Locais com Módulos

Nesta etapa, demonstraremos como importar e utilizar outros módulos locais no seu projeto Go.

O pacote helloWorld na pasta de mesmo nome já foi inicializado com Go Modules. Da mesma forma, o pacote test, que também utiliza módulos, importa a função Say do pacote helloWorld.

Para explorar essa estrutura, siga as instruções abaixo:

Primeiro, observe a estrutura dos diretórios helloWorld e test:

helloWorld
├── go.mod
└── helloWorld.go
test
├── go.mod
└── test.go

Em seguida, abra o arquivo test/go.mod. Você verá o seguinte conteúdo:

module test

go 1.15

require "helloWorld" v0.0.1
replace "helloWorld" => "../helloWorld"

A diretiva replace instrui o Go a usar o caminho local ../helloWorld em vez de tentar buscar o pacote em um repositório externo. A diretiva require especifica que o pacote test depende da versão v0.0.1 do pacote helloWorld.

Parâmetro	Descrição
module	Especifica o nome do módulo atual
require	Define as dependências necessárias
replace	Substitui uma dependência por um caminho local ou outra versão
exclude	Exclui versões específicas de dependências

Para executar o arquivo test.go dentro do pacote test:

cd ~/project/test
go run test.go

O resultado esperado é:

hello, world

Importando Pacotes Remotos

No Go, é muito simples importar pacotes hospedados remotamente. Vamos demonstrar isso utilizando um pacote hospedado no GitHub.

Crie um diretório chamado remoteModule:

cd ~/project
mkdir remoteModule
cd remoteModule

Inicialize o módulo Go:
```
go mod init remoteModule
```
Crie um arquivo remote.go dentro da pasta remoteModule com o seguinte conteúdo:
```
touch remote.go
```
```
package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.StringTobase64("miiy")
}
```
Este programa importa o pacote chap02module do GitHub e utiliza sua função StringTobase64.
Execute o arquivo remote.go usando os seguintes comandos:
```
go get github.com/labex-labs/golang-dev-code/chap02module
go run -v remote.go
```
Dica: Usuários da versão gratuita não possuem acesso à internet externa, portanto não conseguirão executar este comando. Atualize para o plano Pro para obter acesso total à rede.

O comando go get fará o download do pacote chap02module do GitHub e o salvará no cache de módulos do seu sistema. Após a conclusão, o comando go run executará o seu programa.

Mini Desafio

Nesta etapa, vamos testar seus conhecimentos criando um novo arquivo que utiliza a função Hello do módulo remoto.

Crie uma pasta chamada remoteModule2:

cd ~/project
mkdir remoteModule2
cd remoteModule2

Inicialize o módulo Go:
```
go mod init remoteModule2
```

Crie um arquivo remote2.go com o seguinte conteúdo:

touch remote2.go

package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.Hello()
}

Execute o programa:

go get github.com/labex-labs/golang-dev-code/chap02module
go run remote2.go

A saída deve ser:

hello

Resumo

Neste laboratório, aprendemos os seguintes conceitos:

O significado e a finalidade dos diretórios GOPATH e GOROOT.
Os fundamentos dos Go Modules para o gerenciamento de dependências.
Como inicializar e utilizar Go Modules em um projeto real.
Como importar e utilizar pacotes Go tanto locais quanto remotos.

Ao concluir este laboratório, você deve se sentir confortável ao usar Go Modules para gerenciar as dependências em seus projetos Go.