TOC

Comment installer et configurer un environnement de programmation local sur Ubuntu 18.04

introduction

Go est un langage de programmation né de la frustration de Google. Les développeurs devaient continuellement choisir un langage qui s'exécutait efficacement mais mettait beaucoup de temps à compiler, ou un langage facile à programmer, mais dont la production était inefficace. Go a été conçu pour avoir les trois disponibles en même temps: compilation rapide, facilité de programmation et exécution efficace en production.

Bien que Go soit un langage de programmation polyvalent qui puisse être utilisé pour de nombreux projets de programmation, il est particulièrement bien adapté aux programmes réseau / distribués, et a acquis une réputation de «langage du cloud». Son objectif principal est d'aider le programmeur moderne à en faire plus avec un ensemble d'outils performant, en supprimant les débats sur le formatage en intégrant le format dans la spécification de langue, ainsi qu'en facilitant le déploiement en compilant un seul fichier binaire. Go est facile à apprendre, avec un très petit ensemble de mots-clés, ce qui en fait un excellent choix pour les développeurs débutants et expérimentés.

Ce tutoriel vous guidera lors de l'installation et de la configuration d'un espace de travail de programmation avec Go via la ligne de commande. Ce tutoriel couvrira explicitement la procédure d'installation pour Ubuntu 18.04, mais les principes généraux peuvent s'appliquer à d'autres distributions Linux Debian.

Conditions préalables

Vous aurez besoin d'un ordinateur ou d'une machine virtuelle avec Ubuntu 18.04 installé, ainsi que d'un accès administratif à cette machine et d'une connexion Internet. Vous pouvez télécharger ce système d'exploitation via lesUbuntu 18.04 releases page.

[[step-1 -—- setting-up-go]] == Étape 1 - Configuration de Go

Dans cette étape, vous installerez Go en téléchargeant la version actuelle à partir desofficial Go downloads page.

Pour ce faire, vous devez rechercher l’URL de l’archive tarball de la version binaire actuelle. Vous voudrez également noter le hachage SHA256 indiqué à côté, car vous utiliserez ce hachage pourverify the downloaded file.

L’installation et la configuration s’effectuent à l’aide de la ligne de commande, qui est un moyen non graphique d’interagir avec votre ordinateur. Autrement dit, au lieu de cliquer sur des boutons, vous saisissez du texte et recevez également les commentaires de votre ordinateur.

La ligne de commande, également connue sous le nom deshell outerminal, peut vous aider à modifier et à automatiser de nombreuses tâches que vous effectuez quotidiennement sur un ordinateur et constitue un outil essentiel pour les développeurs de logiciels. Il existe de nombreuses commandes de terminal à apprendre qui peuvent vous permettre de faire des choses plus puissantes. Pour plus d'informations sur la ligne de commande, consultez le didacticielIntroduction to the Linux Terminal.

Sur Ubuntu 18.04, vous pouvez trouver l'application Terminal en cliquant sur l'icône Ubuntu dans le coin supérieur gauche de votre écran et en tapantterminal dans la barre de recherche. Cliquez sur l'icône de l'application Terminal pour l'ouvrir. Vous pouvez également appuyer sur les touchesCTRL,ALT etT de votre clavier en même temps pour ouvrir automatiquement l'application Terminal.

Ubuntu Terminal

Une fois le terminal ouvert, vous installerez manuellement les fichiers binaires Go. Bien que vous puissiez utiliser un gestionnaire de packages, tel queapt-get, parcourir les étapes d'installation manuelle vous aidera à comprendre les modifications de configuration de votre système nécessaires pour disposer d'un espace de travail Go valide.

Avant de télécharger Go, assurez-vous que vous vous trouvez dans le répertoire home (~): 

cd ~

Utilisezcurl pour récupérer l'URL de l'archive tar que vous avez copiée depuis la page de téléchargement officielle de Go: 

curl -O https://dl.google.com/go/go1.12.1.linux-amd64.tar.gz

Ensuite, utilisezsha256sum pour vérifier l'archive tar: 

sha256sum go1.12.1.linux-amd64.tar.gz

Le hachage affiché lors de l'exécution de la commande ci-dessus doit correspondre au hachage figurant sur la page de téléchargement. Si ce n'est pas le cas, le fichier n'est pas valide et vous devez le télécharger à nouveau. 

Output2a3fdabf665496a0db5f41ec6af7a9b15a49fbe71a85a50ca38b1f13a103aeec  go1.12.1.linux-amd64.tar.gz

Ensuite, extrayez l'archive téléchargée et installez-la à l'emplacement souhaité sur le système. Il est recommandé de le maintenir sous/usr/local: 

sudo tar -xvf go1.12.1.linux-amd64.tar.gz -C /usr/local

Vous aurez maintenant un répertoire appelégo dans le répertoire/usr/local. Ensuite, changez récursivement le propriétaire et le groupe de ce répertoire enroot: 

sudo chown -R root:root /usr/local/go

Cela sécurisera tous les fichiers et garantira que seul l'utilisateur deroot peut exécuter les binaires Go.

[.note] #Note: bien que/usr/local/go soit l'emplacement officiellement recommandé, certains utilisateurs peuvent préférer ou exiger des chemins différents.
#

Dans cette étape, vous avez téléchargé et installé Go sur votre ordinateur Ubuntu 18.04. Dans l'étape suivante, vous allez configurer votre espace de travail Go.

[[step-2 -—- creating-your-go-workspace]] == Étape 2 - Création de votre espace de travail Go

Vous pouvez créer votre espace de travail de programmation maintenant que Go est installé. L'espace de travail Go contient deux répertoires à la racine:

  • src: répertoire contenant les fichiers source Go. Un fichier source est un fichier que vous écrivez en utilisant le langage de programmation Go. Les fichiers sources sont utilisés par le compilateur Go pour créer un fichier binaire exécutable.

  • bin: le répertoire contenant les exécutables créés et installés par les outils Go. Les exécutables sont des fichiers binaires qui s'exécutent sur votre système et exécutent des tâches. Ce sont généralement les programmes compilés par votre code source ou un autre code source Go téléchargé.

Le sous-répertoiresrc peut contenir plusieurs référentiels de contrôle de version (tels queGit,Mercurial etBazaar). Cela permet une importation canonique de code dans votre projet. Les importationsCanonical sont des importations qui font référence à un package complet, tel quegithub.com/digitalocean/godo.

Vous verrez des répertoires commegithub.com,golang.org ou autres lorsque votre programme importe des bibliothèques tierces. Si vous utilisez un référentiel de code commegithub.com, vous placerez également vos projets et fichiers source dans ce répertoire. Nous explorerons ce concept plus tard dans cette étape.

Voici à quoi peut ressembler un espace de travail typique: 

.
├── bin
│   ├── buffalo                                      # command executable
│   ├── dlv                                          # command executable
│   └── packr                                        # command executable
└── src
    └── github.com
        └── digitalocean
            └── godo
                ├── .git                            # Git repository metadata
                ├── account.go                      # package source
                ├── account_test.go                 # test source
                ├── ...
                ├── timestamp.go
                ├── timestamp_test.go
                └── util
                    ├── droplet.go
                    └── droplet_test.go

Le répertoire par défaut de l'espace de travail Go à partir de la version 1.8 est le répertoire de base de votre utilisateur avec un sous-répertoirego ou$HOME/go. Si vous utilisez une version antérieure de Go à la version 1.8, il est toujours recommandé d'utiliser l'emplacement$HOME/go pour votre espace de travail.

Exécutez la commande suivante pour créer la structure de répertoires pour votre espace de travail Go: 

mkdir -p $HOME/go/{bin,src}

L’option-p indique àmkdir de créer tous lesparents dans le répertoire, même s’ils n’existent pas actuellement. L'utilisation de{bin,src} crée un ensemble d'arguments pourmkdir et lui dit de créer à la fois le répertoirebin et le répertoiresrc.

Cela garantira que la structure de répertoire suivante est maintenant en place: 

└── $HOME
    └── go
        ├── bin
        └── src

Avant Go 1.8, il était nécessaire de définir une variable d'environnement locale appelée$GOPATH. $GOPATH a indiqué au compilateur où trouver le code source tiers importé, ainsi que tout code source local que vous aviez écrit. Bien que cela ne soit plus explicitement requis, cela reste une bonne pratique car de nombreux outils tiers dépendent toujours de la définition de cette variable.

Vous pouvez définir vos$GOPATH en ajoutant les variables globales à vos~/.profile. Vous voudrez peut-être l'ajouter dans le fichier.zshrc ou.bashrc selon la configuration de votre shell.

Tout d'abord, ouvrez~/.profile avecnano ou votre éditeur de texte préféré: 

nano ~/.profile

Définissez vos$GOPATH en ajoutant ce qui suit au fichier:

~/.profile

export GOPATH=$HOME/go

Lorsque Go compile et installe les outils, il les place dans le répertoire$GOPATH/bin. Pour plus de commodité, il est courant d’ajouter le sous-répertoire/bin de l’espace de travail à vosPATH dans vos~/.profile:

~/.profile

export PATH=$PATH:$GOPATH/bin

Cela vous permettra d'exécuter tous les programmes que vous compilez ou téléchargez via les outils Aller n'importe où sur votre système.

Enfin, vous devez ajouter le binairego à vosPATH. Vous pouvez le faire en ajoutant/usr/local/go/bin à la fin de la ligne:

~/.profile

export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin

L'ajout de/usr/local/go/bin à votre$PATH rend tous les outils Go disponibles n'importe où sur votre système.

Pour mettre à jour votre shell, lancez la commande suivante pour charger les variables globales: 

. ~/.profile

Vous pouvez vérifier que votre$PATH est mis à jour en utilisant la commandeecho et en inspectant la sortie: 

echo $PATH

Vous verrez vos$GOPATH/bin qui apparaîtront dans votre répertoire personnel. Si vous êtes connecté en tant queroot, vous verrez/root/go/bin dans le chemin. 

Output/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

Vous verrez également le chemin d'accès aux outils Go pour/usr/local/go/bin: 

Output/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

Vérifiez l'installation en vérifiant la version actuelle de Go: 

go version

Et nous devrions recevoir une sortie comme ceci: 

Outputgo version go1.12.1 linux/amd64

Maintenant que vous avez créé la racine de l'espace de travail et que votre variable d'environnement$GOPATHest définie, vous pouvez créer vos futurs projets avec la structure de répertoires suivante. Cet exemple suppose que vous utilisezgithub.com comme référentiel: 

$GOPATH/src/github.com/username/project

Ainsi, à titre d'exemple, si vous travailliez sur le projethttps://github.com/digitalocean/godo, il serait stocké dans le répertoire suivant: 

$GOPATH/src/github.com/digitalocean/godo

Cette structure de projet rendra les projets disponibles avec l'outilgo get. Cela facilitera également la lisibilité plus tard. Vous pouvez vérifier cela en utilisant la commandego get et en récupérant la bibliothèquegodo: 

go get github.com/digitalocean/godo

Cela téléchargera le contenu de la bibliothèquegodo et créera le répertoire$GOPATH/src/github.com/digitalocean/godo sur votre machine.

Vous pouvez vérifier si le téléchargement du packagegodo a réussi en listant le répertoire: 

ll $GOPATH/src/github.com/digitalocean/godo

Vous devriez voir une sortie semblable à ceci: 

Outputdrwxr-xr-x 4 root root  4096 Apr  5 00:43 ./
drwxr-xr-x 3 root root  4096 Apr  5 00:43 ../
drwxr-xr-x 8 root root  4096 Apr  5 00:43 .git/
-rwxr-xr-x 1 root root     8 Apr  5 00:43 .gitignore*
-rw-r--r-- 1 root root    61 Apr  5 00:43 .travis.yml
-rw-r--r-- 1 root root  2808 Apr  5 00:43 CHANGELOG.md
-rw-r--r-- 1 root root  1851 Apr  5 00:43 CONTRIBUTING.md
.
.
.
-rw-r--r-- 1 root root  4893 Apr  5 00:43 vpcs.go
-rw-r--r-- 1 root root  4091 Apr  5 00:43 vpcs_test.go

Au cours de cette étape, vous avez créé un espace de travail Go et configuré les variables d’environnement nécessaires. Dans l'étape suivante, vous testerez l'espace de travail avec du code.

[[step-3 -—- creating-a-simple-program]] == Étape 3 - Création d'un programme simple

Maintenant que l'espace de travail Go est configuré, créez un programme «Hello, World!». Cela garantira que l'espace de travail est configuré correctement et vous donnera également la possibilité de vous familiariser avec Go. Comme nous créons un seul fichier source Go, et non un projet réel, nous n’avons pas besoin d’être dans notre espace de travail pour le faire.

Depuis votre répertoire personnel, ouvrez un éditeur de texte en ligne de commande, tel quenano, et créez un nouveau fichier: 

nano hello.go

Ecrivez votre programme dans le nouveau fichier: 

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Ce code utilisera le packagefmt et appellera la fonctionPrintln avecHello, World! comme argument. Cela entraînera l'impression de la phraseHello, World! sur le terminal lorsque le programme est exécuté.

Quitteznano en appuyant sur les touchesCTRL etX. Lorsque vous êtes invité à enregistrer le fichier, appuyez surY puis surENTER.

Une fois que vous quitteznano et revenez à votre shell, exécutez le programme: 

go run hello.go

Le programmehello.go amènera le terminal à produire la sortie suivante: 

OutputHello, World!

Au cours de cette étape, vous avez utilisé un programme de base pour vérifier que votre espace de travail Go est correctement configuré.

Conclusion

Toutes nos félicitations! À ce stade, vous avez un espace de travail de programmation Go configuré sur votre machine Ubuntu et pouvez commencer un projet de codage!

Related