Je vais présenter dans ce billet la méthode d'installation de GO sous Ubuntu 9.10. Les informations données ici proviennent directement du site officiel du projet : http://golang.org/

L'installation de Go se fait en 4 étapes :

• Préparation du système
• Définition des variables d'environnement
• Téléchargement depuis le repository
• Compilation / installation des binaires

Remarque : Une fois installer, ne pas supprimer le répertoire source car il contient les librairies nécessaires aux développements de programmes.

1) Préparation du système

Le projet Go a choisi "Mercurial" comme système de gestion des versions. Il va donc être necessaire d'en installer le client "hg" pour récupérer le code source du langage.

Ouvrir une console et taper :

sudo apt-get install mercurial

A présent, nous allons créer les répertoires qui vont accueillir le code source depuis le repository et les binaires qui sont compilés.

J'ai choisis de travailler dans un dossier "bin" situé à la racine de mon home. A l'intérieur de ce dernier, je vais créer les 2 emplacements : go/src/ pour les sources et go/bin/ pour les binaires

# si le dossier bin n'existe pas chez vous : 
mkdir $HOME/bin
 
mkdir $HOME/bin/go
mkdir $HOME/bin/go/src
mkdir $HOME/bin/go/bin

Enfin, la compilation va nécessiter que vous ayez installé les outils... de compilation :)

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

2) Définition des variables d'environnement

La compilation et l'utilisation de Go nécessite la présence de 4 variables d'environnement :

• $GOROOT :
  
  • Le chemin complet vers le dossier contenant les sources de GO
  • Dans notre exemple, $GOROOT aura comme valeur : $HOME/bin/go/src
    
    
• $GOOS : 
  • Le système d'exploitation cible. Peut avoir la valeur :
    • linux
    • darwin - pour Mac OS 10.5 ou 10.6
    • nacl (pour Native Client... ne pas utiliser pour le moment)
      
• $GOARCH : 
  • L'architecture cible de compilation. Peut avoir comme valeur :
    • amd64 - 64-bit x86
    • 386 - pour architecture 32-bit x86
    • arm - pour architecture 32-bit ARM - Portage incomplet !
      
      
• $GOBIN :
  • Le chemin complet vers les binaires.
    
  • Attention, $GOBIN doit être dans le $PATH
  • Dans notre exemple, $GOBIN aura comme valeur : $HOME/bin/go/bin
    

Ces variable d'environnement étant aussi nécessaire à la compilation de programme, il est utile d'automatiser leur déclaration afin de ne pas avoir à le faire à chaque nouvelle session.

Je vais pour cela ajouter au début de mon $HOME/.bashrc :

export GOROOT=$HOME/bin/go/src
export GOOS=linux
export GOARCH=386
export GOBIN=$HOME/bin/go/bin
export PATH=$PATH:$GOBIN

Attention : Afin de déclarer ces variables immédiatement sans redemarrer, il faut taper ces mêmes lignes directement dans la console qui servira à compiler le projet et notre premier programme.

3) Téléchargement des sources depuis le repository

Nous avons vu plus haut que le projet Go a choisi "Mercurial" comme système de gestion des versions.
Nous allons donc nous servir du client hg pour rapatrier les sources dans notre répertoire $HOME/bin/go/src :

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

Quelque secondes (minutes) plus tard, votre console doit ressembler à ça :

requesting all changes
adding changesets
adding manifests
adding file changes
added 4109 changesets with 17125 changes to 2968 files
updating working directory
1676 files updated, 0 files merged, 0 files removed, 0 files unresolved
 

Je vérifie ce qu'il s'est passé avec la commande du :

c461557@c461557-laptop:~$ du -hs $GOROOT
39M	/home/c461557/bin/go/src
 

Nous avons donc téléchargé 39Mo de sources.
C'est un bon début.

4) Compilation & installation

L'équipe du projet Go nous a concocté un petit script de compilation et d'installation qui va bien.
Assurez vous que la variable $GOBIN est bien définie :

c461557@c461557-laptop:~$ echo $GOBIN
/home/c461557/bin/go/bin

Ok c'est bon, rendez vous maintenant dans le dossier des sources :

cd $GOROOT/src

et lancer le script "all.bash" :

./all.bash

La compilation est lancée et va durer de plusieurs secondes à quelques minutes en fonction de votre système. Une fois terminée, la dernière ligne doit vous indiquer :

N known bugs; 0 unexpected bugs

5) Un premier programme pour tester

Créez vous un dossier pour réaliser notre premier test. Pour ma part, je crée le dossier suivant :

mkdir $HOME/bin/go/test

Placez vous dans ce dossier, et éditez un fichier test.go :

vim test.go

Tapez votre premier programme :

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

A présent, nous allons compiler ce programme. Le choix de la commande est fonction de votre système :

• 6g est le compilateur pour amd64 (si $GOARCH == amd64)
• 8g pour 386 (si $GOARCH == 386)
• 5g pour arm

Dans mon cas $GOARCH est sur 386, je me servirai donc de la commande 8g pour compiler mon programme :

c461557@c461557-laptop:~/bin/go/test$ 8g test.go 
c461557@c461557-laptop:~/bin/go/test$ ls -l
total 12
-rw-r--r-- 1 c461557 c461557 5162 2009-11-19 00:00 test.8
-rw-r--r-- 1 c461557 c461557   76 2009-11-18 23:59 test.go
 

Nous allons à présent utiliser le linker correspondant à notre architecture : 8l

c461557@c461557-laptop:~/bin/go/test$ 8l test.8
c461557@c461557-laptop:~/bin/go/test$ ls -l
total 585
-rwxr-xr-x 1 c461557 c461557 582063 2009-11-19 00:02 8.out
-rw-r--r-- 1 c461557 c461557   5162 2009-11-19 00:00 test.8
-rw-r--r-- 1 c461557 c461557     76 2009-11-18 23:59 test.go

C'est finit, nous avons un nouveau fichier exécutable cette fois : 8.out. Lançons le...

c461557@c461557-laptop:~/bin/go/test$ ./8.out
hello, world 

La magie a opérée :)

Et un "Hello world" de plus à notre palmarès de développeur !!!

Il ne me reste plus qu'a explorer les librairie disponible, et suivre ce projet de près.