Samuel Corradi

Instalando Google Go

programacao, linux, google, go, desenvolvimento

Deixo hoje com vocês um tutorial sobre como instalar um ambiente de desenvolvimento Go em quatro etapas. Depois, como extra, temos mais duas etapas mostrando como escrever um pequeno programa e compila-lo.

1 - Variáveis de ambiente

Algumas variáveis de ambiente devem ser setadas para que o compilador do Go funcione adequadamente. São quatro as variáveis de ambiente que devem ser setadas (sendo que, dessas quatro, uma é opcional).

$GOROOT - Essa variável define a raiz de diretório do Go. Normalmente é utilizado o diretório $HOME/go, mas pode ser qualquer outro.

$GOOS - Define o sistema operacional utilizado. As opções disponíveis são linux, darwin (Mac OS X 10.5 ou 10.6), e nacl (Native Client, um port ainda não finalizado).

$GOARCH - Define a arquitetura de processador utilizado pelo sistema. As opções são amd64 (64-bit x86, o port mais maduro), 386 (32-bit x86), e arm (32-bit ARM, um port ainda não finalizado). As combinações válidas para a utilização de $GOOS e $GOARCH são: linux/amd64, linux/arm, linux/386, darwin/amd64, darwin/386, and nacl/386.

$GOBIN - Esse parâmetro é opcional. Ele indica o local onde os binários serão instalados. Se você definir a variável $GOBIN, é preciso se certificar que ela esteja também definida dentro de $PATH. Dessa forma, o compilador pode executar seus comandos durante seu processo. A variável $GOBIN é opcional pois, dependendo da sua versão UNIX like, o padrão $HOME/bin pode já estar definido em seu $PATH. Na versão 9.10 do Ubuntu não está. Então vamos definir usando o comando:

mkdir $HOME/bin
PATH=$PATH:$HOME/bin

Veja um exemplo de como ficou minhas definições de variáveis dentro do arquivo $HOME/.bashrc

export GOROOT=$HOME/go
export GOARCH=386
export GOOS=linux

Para se certificar que as variáveis foram definidas, podemos usar o comando:

env | grep '^GO'

DICA: É possível definir as variáveis de ambiente dentro do arquivo .bashrc que se encontra dentro da sua pasta de usuário (cd ~). Assim, essas variáveis serão setadas todas a vezes que você iniciar um novo terminal. Caso apenas defina as variáveis atribuindo seus valores através do shell, sempre que reiniciar o computador (ou mesmo mudar de terminal), essas variáveis serão perdidas e você terá que redefini-las novamente.

2 - Breve explicação sobre os ports

Os compiladores do Go atualmente suportam dois sistemas operacionais (Linux, Mac OS X) e três tipos de instruções (amd64 [6g,6l,6c,6a], 386 [8g,8l,8c,8a] e ARM [5g,5l,5c,5a]). o amd64 é com o melhor suporte até agora. O 386 é comparado ao amd64, porém o ARM ainda encontra uma série de bugs quando testado com o QEMU e um telefone com Android. No final das contas, por enquanto, caso o trabalho com a linguagem não seja de baixo nível, a execução é o mesma em todos ports, incluindo o garbage collector, manipulação (corte) de arrays e strings, etc.

3 - Instalando o controle de versão Mercurial

O Go usa o Mercurial como controle de versão. Se você não tiver ele instalado, execute o comando:

sudo apt-get install mercurial

Instalado, verifique mais uma vez se a variavel $GOROOT está definida dando echo nela, baixe o repositório do Go:

hg clone -r release https://go.googlecode.com/hg/ $GOROOT

4 - Finalmente, instalando o Go:

Para utilizar o Go, é necessário que seu sistema tenha os seguintes pacotes pré-instalados: GCC (a biblioteca padrão do C), Bison (gerador de parser), o make e o editor de texto ed. Para aqueles que usam OS X, eles podem ser instalados como parte do Xcode. Bem, para quem usa GNU/Linux tipo Debian ou derivados:

sudo apt-get install bison gcc libc6-dev ed make

Para construir o Go, verifique se a variável $GOBIN (ou $HOME/bin se $GOBIN não estiver setado) está definida dentro de seu $PATH e execute:

cd $GOROOT/src
./all.bash

Se o script all.bash rodou corretamente, ele irá terminar imprimindo:

--- cd ../test
N known bugs; 0 unexpected bugs

Onde N é um número que varia de versão para versão.

5 - Hello World

Vamos fazer nosso primeiro Hello Worl. Para isso, vamos criar um arquivo chamada hello.go dentro do diretório /tmp.

cd /tmp
touch hello.go

Edite-o com seu editor favorito:

sudo gedit hello.go

Não vou explicar aqui a sintaxe. Mesmo por que o código eu copiei de um exemplo dado pela equipe do Go. Mas basicamente usamos o pacote básico de instruções (main), importamos a biblioteca fmt (que possui as instruções de saída), e usamos seu método Printf para retornar a frase (dentro da chamada main):

package main
import "fmt"
func main()
{
	fmt.Printf("Hello World")
}

6 - Eba! Compilando e executando

Para compilar usamos os comandos:

8g hello.go
8l hello.8 

É importante observar que usei o comando 8g simplesmente por que meu computador é uma arquitetura 386, então usei a verão 8g do compilador (verão do compilador gc para x86). Se seu computador for um amd64, você deverá usar 6g (veja lá em cima a lista de instruções para cada tipo de processador). Veja a lista de compiladores para o Go aqui.

Finalmente executamos nosso binário:

./8.out
hello, world 

É isso pessoal. Na medida do possível vou publicando coisas novas sobre Go.

Últimos posts:

• Pausa para o café - O universo em escalas
• Localizando o arquivo de um comando no Linux
• Histórico das linguagens de programação
• Duplicando discos virtuais no VirtualBox
• Backup de bases MySQL - mysqlhotcopy
• Tratando erros com PHP - Parte 3 (Final)
• Download do Chrome OS – O open-source foi pilhado
• Instalando Google Go
• Go Google, Go!
• XML - Quando usar elementos ou atributos?

Destaques:

• Sobre
• Trabalhos
• Contato