TOC

So installieren Sie Go und richten eine lokale Programmierumgebung unter Ubuntu 18.04 ein

Einführung

Go ist eine Programmiersprache, die aus Frustration bei Google entstanden ist. Die Entwickler mussten ständig eine Sprache auswählen, die effizient ausgeführt wurde, deren Kompilierung jedoch viel Zeit in Anspruch nahm, oder eine Sprache auswählen, die einfach zu programmieren war, in der Produktion jedoch ineffizient lief. Go wurde so konzipiert, dass alle drei gleichzeitig verfügbar sind: schnelle Kompilierung, einfache Programmierung und effiziente Ausführung in der Produktion.

Go ist eine vielseitige Programmiersprache, die für viele verschiedene Programmierprojekte verwendet werden kann. Sie eignet sich jedoch besonders für Netzwerk- / verteilte Systemprogramme und hat sich den Ruf einer „Sprache der Cloud“ erworben. Es konzentriert sich darauf, den modernen Programmierern dabei zu helfen, mehr mit einem starken Werkzeugsatz zu erreichen, Debatten über die Formatierung zu beseitigen, indem das Format Teil der Sprachspezifikation wird, und die Bereitstellung durch Kompilieren in einer einzelnen Binärdatei zu vereinfachen. Go ist einfach zu erlernen und mit einer sehr kleinen Anzahl von Schlüsselwörtern ausgestattet. Dies macht es zu einer großartigen Wahl für Anfänger und erfahrene Entwickler.

Dieses Tutorial führt Sie über die Befehlszeile durch die Installation und Konfiguration eines Programmierarbeitsbereichs mit Go. Dieses Tutorial wird explizit die Installationsprozedur für Ubuntu 18.04 behandeln, aber die allgemeinen Prinzipien können auf andere Debian-Linux-Distributionen angewendet werden.

Voraussetzungen

Sie benötigen einen Computer oder eine virtuelle Maschine mit Ubuntu 18.04 sowie Administratorzugriff auf diese Maschine und eine Internetverbindung. Sie können dieses Betriebssystem überUbuntu 18.04 releases page herunterladen.

[[Schritt-1 - Einrichten von Go]] == Schritt 1 - Einrichten von Go

In diesem Schritt installieren Sie Go, indem Sie die aktuelle Version vonofficial Go downloads pageherunterladen.

Dazu müssen Sie die URL für den aktuellen binären Release-Tarball suchen. Beachten Sie auch den daneben aufgeführten SHA256-Hash, da Sie diesen Hash fürverify the downloaded file verwenden.

Sie schließen die Installation und Einrichtung über die Befehlszeile ab. Dies ist eine nicht grafische Methode, um mit Ihrem Computer zu interagieren. Das heißt, anstatt auf Schaltflächen zu klicken, geben Sie Text ein und erhalten auch Text-Feedback von Ihrem Computer.

Die Befehlszeile, auch alsshell oderterminal bezeichnet, kann Ihnen dabei helfen, viele der Aufgaben, die Sie täglich auf einem Computer ausführen, zu ändern und zu automatisieren. Sie ist ein wichtiges Werkzeug für Softwareentwickler. Es müssen viele Terminalbefehle gelernt werden, mit denen Sie leistungsstärkere Aufgaben ausführen können. Weitere Informationen zur Befehlszeile finden Sie im Tutorial vonIntroduction to the Linux Terminal.

Unter Ubuntu 18.04 finden Sie die Terminal-Anwendung, indem Sie auf das Ubuntu-Symbol in der oberen linken Ecke Ihres Bildschirms klicken undterminal in die Suchleiste eingeben. Klicken Sie auf das Terminal-Anwendungssymbol, um es zu öffnen. Alternativ können Sie gleichzeitig die TastenCTRL,ALT undT auf Ihrer Tastatur drücken, um die Terminal-Anwendung automatisch zu öffnen.

Ubuntu Terminal

Sobald das Terminal geöffnet ist, installieren Sie die Go-Binärdateien manuell. Sie können zwar einen Paketmanager wieapt-get verwenden, aber wenn Sie die manuellen Installationsschritte durchgehen, können Sie alle Konfigurationsänderungen an Ihrem System verstehen, die für einen gültigen Go-Arbeitsbereich erforderlich sind.

Stellen Sie vor dem Herunterladen von Go sicher, dass Sie sich im Ausgangsverzeichnis (~) befinden: 

cd ~

Verwenden Siecurl, um die Tarball-URL abzurufen, die Sie von der offiziellen Go-Downloadseite kopiert haben: 

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

Verwenden Sie als Nächstessha256sum, um den Tarball zu überprüfen: 

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

Der Hash, der beim Ausführen des obigen Befehls angezeigt wird, sollte mit dem Hash auf der Downloadseite übereinstimmen. Wenn dies nicht der Fall ist, ist dies keine gültige Datei und Sie sollten die Datei erneut herunterladen. 

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

Extrahieren Sie anschließend das heruntergeladene Archiv und installieren Sie es am gewünschten Speicherort auf dem System. Es wird als bewährte Methode angesehen, es unter/usr/local zu halten: 

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

Sie haben jetzt ein Verzeichnis namensgo im Verzeichnis/usr/local. Ändern Sie als Nächstes rekursiv den Eigentümer und die Gruppe dieses Verzeichnisses inroot: 

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

Dadurch werden alle Dateien gesichert und sichergestellt, dass nur der Benutzer vonrootdie Go-Binärdateien ausführen kann.

[.note] #Note: Obwohl/usr/local/go der offiziell empfohlene Speicherort ist, bevorzugen oder benötigen einige Benutzer möglicherweise andere Pfade.
#

In diesem Schritt haben Sie Go auf Ihren Ubuntu 18.04-Rechner heruntergeladen und installiert. Im nächsten Schritt konfigurieren Sie Ihren Go-Arbeitsbereich.

[[Schritt-2 - Erstellen Ihres Go-Arbeitsbereichs]] == Schritt 2 - Erstellen Ihres Go-Arbeitsbereichs

Sie können Ihren Programmierarbeitsbereich jetzt erstellen, wenn Go installiert ist. Der Go-Arbeitsbereich enthält im Stammverzeichnis zwei Verzeichnisse:

  • src: Das Verzeichnis, das Go-Quelldateien enthält. Eine Quelldatei ist eine Datei, die Sie mit der Programmiersprache Go schreiben. Quelldateien werden vom Go-Compiler zum Erstellen einer ausführbaren Binärdatei verwendet.

  • bin: Das Verzeichnis, das ausführbare Dateien enthält, die von den Go-Tools erstellt und installiert wurden. Ausführbare Dateien sind Binärdateien, die auf Ihrem System ausgeführt werden und Aufgaben ausführen. Dies sind normalerweise die Programme, die von Ihrem Quellcode oder einem anderen heruntergeladenen Go-Quellcode kompiliert wurden.

Das Unterverzeichnissrc kann mehrere Versionskontroll-Repositorys enthalten (z. B.Git,Mercurial undBazaar). Dies ermöglicht einen kanonischen Import von Code in Ihr Projekt. Canonical Importe sind Importe, die auf ein vollständig qualifiziertes Paket verweisen, z. B.github.com/digitalocean/godo.

Sie sehen Verzeichnisse wiegithub.com,golang.org oder andere, wenn Ihr Programm Bibliotheken von Drittanbietern importiert. Wenn Sie ein Code-Repository wiegithub.com verwenden, legen Sie auch Ihre Projekte und Quelldateien in diesem Verzeichnis ab. Wir werden dieses Konzept später in diesem Schritt untersuchen.

So sieht ein typischer Arbeitsbereich aus: 

.
├── 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

Das Standardverzeichnis für den Go-Arbeitsbereich ab 1.8 ist das Ausgangsverzeichnis Ihres Benutzers mit dem Unterverzeichnisgo oder$HOME/go. Wenn Sie eine frühere Version von Go als 1.8 verwenden, wird es immer noch als bewährte Methode angesehen, den Speicherort von$HOME/gofür Ihren Arbeitsbereich zu verwenden.

Geben Sie den folgenden Befehl ein, um die Verzeichnisstruktur für Ihren Go-Arbeitsbereich zu erstellen: 

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

Die Option-p weistmkdir an, alleparents im Verzeichnis zu erstellen, auch wenn sie derzeit nicht vorhanden sind. Die Verwendung von{bin,src} erstellt eine Reihe von Argumenten fürmkdir und weist es an, sowohl das Verzeichnisbin als auch das Verzeichnissrc zu erstellen.

Dadurch wird sichergestellt, dass die folgende Verzeichnisstruktur jetzt vorhanden ist: 

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

Vor Go 1.8 musste eine lokale Umgebungsvariable namens$GOPATH festgelegt werden. $GOPATH teilte dem Compiler mit, wo importierter Quellcode von Drittanbietern sowie der von Ihnen geschriebene lokale Quellcode zu finden sind. Dies ist zwar nicht mehr ausdrücklich erforderlich, wird jedoch weiterhin als bewährte Methode angesehen, da viele Tools von Drittanbietern weiterhin davon abhängen, dass diese Variable festgelegt wird.

Sie können Ihre$GOPATH festlegen, indem Sie die globalen Variablen zu Ihren~/.profile hinzufügen. Möglicherweise möchten Sie dies gemäß Ihrer Shell-Konfiguration in die Datei.zshrc oder.bashrc einfügen.

Öffnen Sie zunächst~/.profile mitnano oder Ihrem bevorzugten Texteditor: 

nano ~/.profile

Stellen Sie Ihre$GOPATH ein, indem Sie der Datei Folgendes hinzufügen:

~/.profile

export GOPATH=$HOME/go

Wenn Go Tools kompiliert und installiert, werden sie im Verzeichnis$GOPATH/binabgelegt. Der Einfachheit halber ist es üblich, das Unterverzeichnis/bindes Arbeitsbereichs zu IhrenPATH in Ihren~/.profile hinzuzufügen:

~/.profile

export PATH=$PATH:$GOPATH/bin

Auf diese Weise können Sie alle Programme ausführen, die Sie über die Go-Tools kompilieren oder herunterladen, und zwar überall auf Ihrem System.

Schließlich müssen Sie diego-Binärdatei zu IhrenPATH hinzufügen. Sie können dies tun, indem Sie/usr/local/go/bin am Ende der Zeile hinzufügen:

~/.profile

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

Durch Hinzufügen von/usr/local/go/bin zu$PATH sind alle Go-Tools überall auf Ihrem System verfügbar.

Geben Sie zum Aktualisieren Ihrer Shell den folgenden Befehl ein, um die globalen Variablen zu laden: 

. ~/.profile

Sie können überprüfen, ob Ihre$PATH aktualisiert wurden, indem Sie den Befehlecho verwenden und die Ausgabe überprüfen: 

echo $PATH

Sie sehen Ihre$GOPATH/bin, die in Ihrem Home-Verzeichnis angezeigt werden. Wenn Sie alsroot angemeldet sind, wird/root/go/bin im Pfad angezeigt. 

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

Sie sehen auch den Pfad zu den Go-Werkzeugen für/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

Überprüfen Sie die Installation, indem Sie die aktuelle Version von Go überprüfen: 

go version

Und wir sollten eine Ausgabe wie diese erhalten: 

Outputgo version go1.12.1 linux/amd64

Nachdem Sie das Stammverzeichnis des Arbeitsbereichs erstellt und die Umgebungsvariable$GOPATHfestgelegt haben, können Sie Ihre zukünftigen Projekte mit der folgenden Verzeichnisstruktur erstellen. In diesem Beispiel wird davon ausgegangen, dass Siegithub.com als Repository verwenden: 

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

Wenn Sie beispielsweise am Projekthttps://github.com/digitalocean/godoarbeiten, wird es im folgenden Verzeichnis gespeichert: 

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

Diese Projektstruktur stellt Projekte mit dem Toolgo getzur Verfügung. Dies wird später auch die Lesbarkeit verbessern. Sie können dies mit dem Befehlgo get überprüfen und die Bibliothekgodoabrufen: 

go get github.com/digitalocean/godo

Dadurch wird der Inhalt der Bibliothekgodoheruntergeladen und das Verzeichnis$GOPATH/src/github.com/digitalocean/godoauf Ihrem Computer erstellt.

Sie können überprüfen, ob das Paketgodoerfolgreich heruntergeladen wurde, indem Sie das Verzeichnis auflisten: 

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

Sie sollten eine Ausgabe ähnlich der folgenden sehen: 

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

In diesem Schritt haben Sie einen Go-Arbeitsbereich erstellt und die erforderlichen Umgebungsvariablen konfiguriert. Im nächsten Schritt testen Sie den Arbeitsbereich mit etwas Code.

[[Schritt 3 - Erstellen eines einfachen Programms]] == Schritt 3 - Erstellen eines einfachen Programms

Nachdem Sie den Go-Arbeitsbereich eingerichtet haben, erstellen Sie ein "Hallo, Welt!" - Programm. Dadurch wird sichergestellt, dass der Arbeitsbereich ordnungsgemäß konfiguriert ist, und Sie können sich mit Go vertraut machen. Da wir eine einzelne Go-Quelldatei und kein tatsächliches Projekt erstellen, müssen wir uns nicht in unserem Arbeitsbereich befinden, um dies zu tun.

Öffnen Sie in Ihrem Home-Verzeichnis einen Befehlszeilentexteditor, z. B.nano, und erstellen Sie eine neue Datei: 

nano hello.go

Schreiben Sie Ihr Programm in die neue Datei: 

package main

import "fmt"

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

Dieser Code verwendet das Paketfmt und ruft die FunktionPrintln mitHello, World! als Argument auf. Dadurch wird die PhraseHello, World! beim Ausführen des Programms auf dem Terminal ausgedruckt.

Beenden Sienano, indem Sie die TastenCTRL undX drücken. Wenn Sie aufgefordert werden, die Datei zu speichern, drücken SieY und dannENTER.

Wenn Sienano verlassen und zu Ihrer Shell zurückkehren, führen Sie das folgende Programm aus: 

go run hello.go

Das Programmhello.go bewirkt, dass das Terminal die folgende Ausgabe erzeugt: 

OutputHello, World!

In diesem Schritt haben Sie mit einem Basisprogramm überprüft, ob Ihr Go-Arbeitsbereich ordnungsgemäß konfiguriert ist.

Fazit

Herzliche Glückwünsche! Zu diesem Zeitpunkt haben Sie einen Arbeitsbereich für die Go-Programmierung auf Ihrem Ubuntu-Computer eingerichtet und können ein Codierungsprojekt starten!

Related