TOC

Comment installer Go et configurer un environnement de programmation local sous Windows 10

introduction

https://golang.org [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 à travers l’installation de Go sur votre ordinateur Windows 10 local et la configuration d’un environnement de programmation via la ligne de commande.

Conditions préalables

Vous aurez besoin d’une machine Windows 10 avec un accès administrateur connecté à Internet.

Étape 1 - Ouverture et configuration de PowerShell

Vous effectuerez la majeure partie de l’installation et de la configuration sur une interface de ligne de commande, qui constitue 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 appelée shell, peut vous aider à modifier et à automatiser de nombreuses tâches quotidiennes sur un ordinateur. Elle constitue un outil essentiel pour les développeurs de logiciels.

PowerShell est un programme de Microsoft qui fournit une interface de shell en ligne de commande. Les tâches administratives sont exécutées en exécutant cmdlets, prononcé command-lets, qui sont des classes spécialisées du framework logiciel .NET pouvant effectuer des opérations. Open-sourced en août 2016, PowerShell est désormais disponible sur toutes les plates-formes, pour les systèmes Windows et UNIX (y compris Mac et Linux).

Pour rechercher Windows PowerShell, vous pouvez cliquer avec le bouton droit de la souris sur l’icône du menu * Démarrer * située dans le coin inférieur gauche de votre écran. Lorsque le menu apparaît, cliquez sur * Search *, puis tapez + PowerShell dans la barre de recherche. Lorsque des options vous sont présentées, cliquez avec le bouton droit de la souris sur * Windows PowerShell * dans l’application Bureau. Pour les besoins de ce tutoriel, sélectionnez * Exécuter en tant qu’administrateur *. Lorsque vous êtes invité avec une boîte de dialogue qui vous demande * Voulez-vous autoriser cette application à apporter des modifications à votre PC? * Cliquez sur * Oui *.

Une fois que cela est fait, vous verrez une interface textuelle comportant une chaîne de mots ressemblant à ceci:

image: https: //assets.digitalocean.com/articles/eng_python/Win10SetUp/Win10SetUp.png [Windows 10 PowerShell]

Quittez le dossier système en tapant la commande suivante:

cd ~

Vous serez alors dans un répertoire de base tel que + PS C: \ Users \ +.

Pour poursuivre le processus d’installation, vous devez d’abord configurer des autorisations via PowerShell. Configuré pour s’exécuter dans le mode le plus sécurisé par défaut, il existe quelques niveaux d’autorisations que vous pouvez configurer en tant qu’administrateur:

  • * Restricted * est la politique d’exécution par défaut. Dans ce mode, vous ne pourrez pas exécuter de scripts et PowerShell fonctionnera uniquement en tant que shell interactif.

  • * AllSigned * vous permettra d’exécuter tous les scripts et fichiers de configuration signés par un éditeur approuvé, ce qui signifie que vous pourriez potentiellement ouvrir votre ordinateur au risque d’exécuter des scripts malveillants signés par un éditeur approuvé.

  • * RemoteSigned * vous permettra d’exécuter des scripts et des fichiers de configuration téléchargés sur Internet, signés par des éditeurs de confiance, ce qui ouvrira à nouveau votre ordinateur aux vulnérabilités si ces scripts de confiance sont réellement malveillants.

  • * Unrestricted * exécutera tous les scripts et les fichiers de configuration téléchargés sur Internet dès que vous confirmerez que vous comprenez que le fichier a été téléchargé sur Internet. Dans ce cas, aucune signature numérique n’est requise. Vous risquez donc d’ouvrir votre ordinateur au risque d’exécuter des scripts non signés et potentiellement malveillants téléchargés depuis Internet.

Dans ce tutoriel, vous utiliserez la stratégie d’exécution + RemoteSigned + pour définir les autorisations pour l’utilisateur actuel. Cela permettra à PowerShell d’accepter des scripts sécurisés sans rendre les autorisations aussi larges qu’elles le seraient avec une autorisation + Unrestricted +. Entrez les informations suivantes dans PowerShell:

Set-ExecutionPolicy -Scope CurrentUser

PowerShell vous invitera ensuite à fournir une stratégie d’exécution. Entrez ce qui suit pour utiliser + RemoteSigned +:

RemoteSigned

Une fois que vous avez appuyé sur + ENTER +, il vous sera demandé de confirmer la modification de la stratégie d’exécution. Tapez la lettre + y + pour que les modifications prennent effet. Vous pouvez confirmer que cela a fonctionné en demandant les autorisations en cours sur la machine:

Get-ExecutionPolicy -List

Vous devriez recevoir une sortie qui ressemble à ceci:

Output        Scope ExecutionPolicy
       ----- ---------------
MachinePolicy       Undefined
  UserPolicy       Undefined
     Process       Undefined
 CurrentUser    RemoteSigned
LocalMachine       Undefined

Cela confirme que l’utilisateur actuel peut exécuter des scripts sécurisés téléchargés à partir d’Internet. Vous pouvez maintenant passer au téléchargement des fichiers nécessaires à la configuration de notre environnement de programmation Go.

Étape 2 - Installation du gestionnaire de paquets Chocolatey

Un gestionnaire de paquets _ est un ensemble d’outils logiciels permettant d’automatiser les processus d’installation. Cela inclut l’installation initiale, la mise à niveau et la configuration du logiciel, ainsi que la suppression du logiciel si nécessaire. Ils conservent les installations logicielles dans un emplacement central et peuvent gérer tous les packages logiciels du système dans des formats couramment utilisés.

Chocolatey est un gestionnaire de paquets en ligne de commande conçu pour Windows qui fonctionne comme + apt-get + sous Linux. Disponible dans une version open-source, Chocolatey vous aidera à installer rapidement des applications et des outils. Vous allez l’utiliser pour télécharger ce dont vous avez besoin pour votre environnement de développement.

Avant d’installer le script, lisez-le pour vérifier que vous êtes satisfait des modifications qu’il apportera à votre ordinateur. Pour ce faire, utilisez la structure de script .NET pour télécharger et afficher le script Chocolatey dans la fenêtre du terminal.

Commencez par créer un objet WebClient appelé + $ script + qui partage les paramètres de connexion Internet avec Internet Explorer:

$script = New-Object Net.WebClient

Jetez un coup d’œil aux options disponibles en dirigeant l’objet + $ script avec` + | + vers la classe + Get-Member In`:

$script | Get-Member

Cela renverra tous les membres (propriétés et méthodes) de cet objet WebClient:

Snippet of Output . . .
DownloadFileAsync         Method     void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur...
DownloadFileTaskAsync     Method     System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa...
DownloadString            Method     string DownloadString(string address), string DownloadString(uri address) #method we will use
DownloadStringAsync       Method     void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy...
DownloadStringTaskAsync   Method     System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy…
. . .

En parcourant la sortie, vous pouvez identifier la méthode + DownloadString + utilisée pour afficher le script et la signature dans la fenêtre PowerShell. Utilisez cette méthode pour inspecter le script:

$script.DownloadString("https://chocolatey.org/install.ps1")

Après avoir inspecté le script, installez Chocolatey en tapant ce qui suit dans PowerShell:

iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

La cmdlet + iwr + ou + Invoke-WebRequest + vous permet d’extraire des données du Web. Cela transmettra le script à + ​​iex +, ou à la cmdlet + Invoke-Expression +, qui exécutera le contenu du script et exécutera l’installation pour le gestionnaire de packages Chocolatey.

Autorisez PowerShell à installer Chocolatey. Une fois l’installation terminée, vous pouvez commencer à installer des outils supplémentaires avec la commande + choco +.

Si vous avez besoin de mettre à jour Chocolatey à tout moment, exécutez la commande suivante:

choco upgrade chocolatey

Avec le gestionnaire de paquets installé, vous pouvez installer le reste de ce dont vous avez besoin pour l’environnement de programmation Go.

Étape 3 - Installation de l’éditeur de texte Nano (facultatif)

Dans cette étape, vous allez installer nano, un éditeur de texte utilisant une interface de ligne de commande. Vous pouvez utiliser nano pour écrire des programmes directement dans PowerShell. Cette étape n’est pas obligatoire car vous pouvez également utiliser un éditeur de texte avec une interface utilisateur graphique telle que le Bloc-notes. Ce tutoriel recommande d’utiliser nano, car cela vous aidera à vous habituer à utiliser PowerShell.

Utilisez Chocolatey pour installer nano:

choco install -y nano

L’indicateur + -y + confirme automatiquement que vous souhaitez exécuter le script sans y être invité.

Une fois que nano est installé, vous pouvez utiliser la commande + nano + pour créer de nouveaux fichiers texte. Vous l’utiliserez plus tard dans ce didacticiel pour écrire votre premier programme Go.

Étape 4 - Installation de Go

Comme vous l’avez fait avec nano à l’étape précédente, vous utiliserez Chocolatey pour installer Go:

choco install -y golang

PowerShell va maintenant installer Go, générant une sortie dans PowerShell au cours de ce processus. Une fois l’installation terminée, vous devriez voir la sortie suivante:

OutputEnvironment Vars (like PATH) have changed. Close/reopen your shell to
see the changes (or in powershell/cmd.exe just type `refreshenv`).
The install of golang was successful.
Software installed as 'msi', install location is likely default.

Chocolatey installed 1/1 packages.
See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).

Une fois l’installation terminée, vous allez maintenant confirmer que Go est installé. Pour voir les modifications, fermez et rouvrez PowerShell en tant qu’administrateur, puis vérifiez la version de Go disponible sur votre ordinateur local:

go version

Vous recevrez une sortie semblable à celle-ci:

Outputgo version

Une fois que Go est installé, vous pouvez configurer un espace de travail pour vos projets de développement.

Étape 5 - Création de votre espace de travail Go

Maintenant que vous avez installé Chocolatey, nano et Go, vous pouvez créer votre espace de travail de programmation.

L’espace de travail Go contient deux répertoires à la racine:

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

  • + bin +: Le répertoire qui contient les exécutables construits 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épertoire + src + peut contenir plusieurs référentiels de contrôle de version (tels que Git, Mercurial et http: //. bazaar.canonical.com [Bazar]). Vous verrez des répertoires tels que + github.com + ou + golang.org + lorsque votre programme importera des bibliothèques tierces. Si vous utilisez un référentiel de code comme + github.com +, vous placerez également vos projets et fichiers sources dans ce répertoire. Cela permet une importation canonique de code dans votre projet. Les importations Canonical sont des importations qui font référence à un package entièrement qualifié, tel que + github.com / digitalocean / godo +.

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épertoire + go +, ou + $ HOME / go +. Si vous utilisez une version antérieure de Go inférieure à 1.8, il est toujours recommandé d’utiliser l’emplacement + $ HOME / go + pour votre espace de travail.

Exécutez la commande suivante pour accéder au répertoire + $ HOME +:

cd $HOME

Ensuite, créez la structure de répertoires pour votre espace de travail Go:

mkdir go/bin, go/src

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 local appelée + $ GOPATH +. 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.

Puisque vous avez utilisé Chocolatey pour l’installation, cette variable d’environnement doit déjà être définie. Vous pouvez le vérifier avec la commande suivante:

$env:GOPATH

Vous devriez voir la sortie suivante, avec votre nom d’utilisateur à la place de + sammy +:

OutputC:\Users\\go

Lorsque Go compile et installe des 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 à votre` + $ PATH`. Vous pouvez le faire en utilisant la commande + setx + dans PowerShell:

setx PATH "$($env:path);$GOPATH\bin"

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

Maintenant que vous avez créé la racine de l’espace de travail et que votre variable d’environnement + $ GOPATH + est définie, vous allez créer vos futurs projets avec la structure de répertoires suivante. Cet exemple suppose que vous utilisez https://www.github.com [github.com] comme référentiel:

$GOPATH/src///

Si vous travailliez sur le projet https://github.com/digitalocean/godo, vous le placeriez dans le répertoire suivant:

$GOPATH/src///

En structurant vos projets de cette manière, les projets seront disponibles avec l’outil + go get +. Cela facilitera également la lisibilité plus tard.

Vous pouvez le vérifier en utilisant la commande + go get + pour récupérer la bibliothèque + godo +:

go get github.com/digitalocean/godo

Vous pouvez le voir télécharger avec succès le paquet + godo + en listant le répertoire:

ls $env:GOPATH/src/github.com/digitalocean/godo

Vous recevrez une sortie similaire à celle-ci:

Output    Directory: C:\Users\sammy\go\src\github.com\digitalocean\godo


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----        4/10/2019   2:59 PM                util
-a----        4/10/2019   2:59 PM              9 .gitignore
-a----        4/10/2019   2:59 PM             69 .travis.yml
-a----        4/10/2019   2:59 PM           1592 account.go
-a----        4/10/2019   2:59 PM           1679 account_test.go
-rw-r--r--  1 sammy  staff   2892 Apr  5 15:56 CHANGELOG.md
-rw-r--r--  1 sammy  staff   1851 Apr  5 15:56 CONTRIBUTING.md
.
.
.
-a----        4/10/2019   2:59 PM           5076 vpcs.go
-a----        4/10/2019   2:59 PM           4309 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.

Étape 6 - Création d’un programme simple

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

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

nano hello.go

Une fois le fichier texte ouvert dans nano, tapez votre programme:

bonjour.go

package main

import "fmt"

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

Quittez + nano + en appuyant sur les touches + CTRL + et + X +. Lorsque vous êtes invité à enregistrer le fichier, appuyez sur + Y + puis + ENTER +.

Ce code utilisera le paquetage + fmt + et appellera la fonction + Println + avec + Hello, World! + Comme argument. La phrase + Hello, World! + Sera alors imprimée sur le terminal lors de l’exécution du programme.

Une fois que vous quittez + nano + et revenez dans votre shell, lancez le programme:

go run hello.go

Le programme hello.go que vous venez de créer doit permettre à PowerShell de générer le résultat suivant:

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 ordinateur Windows local et pouvez commencer un projet de codage!

Related