Cum se creează executabile GO în Ubuntu 17

Unul dintre cele mai versatile sisteme de operare din Linux Este, fără îndoială, Ubuntu care, datorită caracteristicilor sale, ne oferă un mediu sigur și extrem de configurabil.

Pe lângă acest mare avantaj, putem găsi numeroase instrumente și aplicații care permit creșterea nivelurilor de performanță și productivitate oferite de Ubuntu și pe baza acestei posibilități astăzi vom analiza un instrument care ne oferă posibilitatea de a crea fișiere executabile ale diferitelor sisteme de operare pentru a fi executate ulterior cu încredere deplină, acest instrument se numește Merge.

Ce este GOGo este o aplicație open source care ne permite să creăm software simplu, fiabil și extrem de productiv.

Go a fost proiectat cu un portofoliu mare de instrumente care permit obținerea pachetelor și crearea executabilelor într-un mod practic.

Cu Go, în calitate de administratori de sistem, vom avea posibilitatea de a crea executabile pentru mai multe sisteme de operare și de a le gestiona pe toate de pe un singur server, fără a fi nevoie să mergeți la fiecare platformă pentru a descărca executabilul corespunzător.

Cu Go putem crea executabile pentru Windows, Linux, Mac OS, printre altele.

Înainte de a vedea cum să creați executabilul, vom face o scurtă trecere în revistă a modului de instalare a Go în Ubuntu 17.

1. Cum se instalează și se actualizează sistemul Ubuntu 17

Pasul 1
Primul pas de realizat este să executați următoarele comenzi pentru a actualiza pachetele de sistem și remedierile lor de erori respective:

 sudo apt-get update sudo apt-get -y upgrade

Pasul 2
Odată ce sistemul este actualizat, continuăm să descărcăm binele Go respective executând următoarea linie:

 wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz 

MARI

NotăÎn cazul în care sunt necesare binare pentru edițiile pe 32 de biți, putem accesa următorul link:

Pasul 3
Odată descărcat fișierul, procedăm la extragerea acestuia executând următoarea linie:

 sudo tar -xvf go1.7.4.linux-amd64.tar.gz 

MARI

Pasul 4
Vom muta conținutul pe calea / usr / local:

 sudo mv go / usr / local

2. Cum se ajustează mediul Go Ubuntu 17

Pasul 1
Pentru ca Go să funcționeze corect, va trebui să introducem următoarele linii asociate cu calea și accesul lui Go:

 export GOROOT = / usr / local / go export GOPATH = $ HOME / Solvetic / go export PATH = $ GOPATH / bin: $ GOROOT / bin: $ PATH

MARI

Pasul 2
Este important să rețineți că calea GOPATH este locul unde vor fi găzduite fișierele de compilare.
După ce se face acest lucru, putem executa următoarele comenzi pentru a verifica versiunea și mediul Go:

 go version go env

MARI

Pasul 3
Cu aceasta am instalat deja Go și putem trece la crearea executabilelor.
Trebuie remarcat faptul că Go versiunea 1.8 este în prezent în versiune beta, dar dacă dorim să o instalăm putem executa următoarele comenzi:

 sudo add-apt-repository ppa: longsleep / golang-backports sudo apt-get update sudo apt-get install golang-go

3. Cum se descarcă codul sursă în Ubuntu 17

Acesta este pasul inițial înainte de a crea orice executabil cu Go, obținându-i codul sursă pe care îl obținem folosind parametrul go get.

Procesul include clonarea pachetelor în calea GOPATH / src / și ulterior, dacă le aplicați, acestea vor fi construite în calea GOPATH / bin.

Pasul 1
Sintaxa de utilizat pentru descărcarea codului sursă este:

 mergi să iei (calea pachetului)

Calea se găsește de obicei la baza Github. Vom adăuga, de asemenea, parametrul -sau care instalează toate dependențele sau actualizarea acestora.

Pasul 2
Pentru acest caz vom folosi Caddy care este un server web scris în Go și vom executa următoarea linie pentru a-l descărca:

 accesați -u github.com/mholt/caddy/caddy

Pasul 3
După cum putem vedea, nu se afișează niciun rezultat vizibil, dar tot conținutul va fi stocat în cale

 GOPATH / src / github.com / mholt / caddy.

Dacă vrem să o verificăm, putem executa linia care caddy. In unele cazuri, Erori asociate Git, pentru aceasta vom executa următoarele pentru corectarea acestuia:

 sudo apt install git

4. Cum se construiește executabilul în Ubuntu 17

Pasul 1
Odată ce Caddy a fost descărcat și pentru aceasta vom executa următoarea linie:

 du-te la construirea github.com/mholt/caddy/caddy 

Pasul 2
Nici această comandă nu va afișa rezultate vizibile. Dacă dorim să specificăm un traseu special, putem adăuga parametrul -o după cum urmează. Putem schimba ruta build / caddy-server pentru cel dorit. Această comandă va crea fișierul executabil și incidental, dacă nu există, directorul ./construi.

 du-te build -o build / caddy-server github.com/mholt/caddy/caddy 

5. Cum se instalează executabilul în Ubuntu 17

Instalarea unui executabil constă din creați fișierul .exe și păstrați-l în Calea GOPATH / bin. Pentru acest proces vom folosi comanda du-te la instalare care va crea executabilul în locul corect.

Vom executa următoarele. La executarea comenzii, niciun rezultat nu va fi vizibil pentru utilizator, dar fișierul va fi creat în calea GOPATH / bin.

 du-te la instalarea github.com/mholt/caddy/caddy 

6. construiți executabile pentru diferite sisteme pe Ubuntu 17

În acest moment vom vedea puterea Go și cum devine un aliat valoros datorită multiplelor posibilități de a crea executabile.

Pasul 1
Sintaxa de implementat va fi următoarea. Comanda env este responsabil de crearea unui mediu modificat pentru utilizarea variabilelor respective.

 env GOOS = Obiectivul sistemului de operare GOARCH = Arhitectura merge construi Calea pachetului 

Pasul 2
Următorul este un tabel cu toate opțiunile oferite de Go:

Pasul 3
În acest caz, vom crea un executabil Windows cu o arhitectură amd pe 64 de biți, vom executa următoarele:

 env GOOS = windows GOARCH = amd64 go build github.com/mholt/caddy/caddy 

După cum este obișnuit în Go, nu vom vedea rezultate vizibile, dar procesul a fost realizat intern.

Pasul 4
Aceasta va crea fișierul .exe pe baza sistemului ales și pentru a-l verifica vom executa următoarea linie:

 ls caddy.exe 

7. Cum se creează scriptul pentru compilarea pe mai multe platforme în Ubuntu 17

Cu acest obiectiv vom crea un script numit go-executable-build.bash care va fi un script care este responsabil pentru desfășurarea tuturor acțiunilor de compilare într-un mod practic și poate fi utilizat la nivel general, cu compatibilitate deplină.

Pasul 1
Pentru aceasta vom folosi linia cd ~ și vom executa următoarele:

 nano go-executable-build.bash

Pasul 2
Acolo trebuie să introducem următoarele informații:

 #! / usr / bin / env bash package = $ 1 if [[-z "$ package"]]; apoi ecou "utilizare: $ 0" ieșire 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} platforme = ("windows / amd64" "windows / 386" "darwin / amd64 ") pentru platformă în" $ {platforme [@]} "face platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ nume_pachet '-' $ GOOS '-' $ GOARCH dacă [$ GOOS = "windows"]; apoi output_name + = '. exe' fi env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ pachet dacă [$? -ne 0]; apoi ecou „A apărut o eroare! Anularea executării scriptului … „ieșirea 1 fi terminată

Pasul 3
Acesta va fi scriptul și funcția sa este următoarea:

 #! / usr / bin / env bash: Această linie indică faptul că interpretul va analiza scriptul. 

 pachet = $ 1: Această linie va prelua primul argument din linia de comandă și îl va stoca în variabila sa. dacă [[-z "$ pachet"]]; apoi ecou „utilizare: $ 0” ieșire 1 fi

Pasul 4
Aceste linii sunt responsabile de afișarea unui mesaj în cazul în care valoarea nu a fost introdusă.
Parametru dacă analizează valoarea variabilei pachet.

 package_split = ($ {package // \ //}): Această linie împarte calea de import a pachetului într-o matrice folosind / delimitatorul. package_name = $ {package_split [-1]}: Această linie ia numele matricei. platforme = ("windows / amd64" "windows / 386" "darwin / amd64"): Acolo vom introduce sistemul de operare și arhitectura de creat. pentru platformă în „$ {platforme [@]}” face platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Gata

Pasul 5
Aceste linii împart valorile platformei în variabilele GOOS și GOARCH.

 output_name = $ package_name '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; apoi output_name + = '. exe' fi

Pasul 6
Cu această secvență vom crea numele executabilului și atunci când vine vorba de sistemele de operare Windows trebuie să adăugăm extensia .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ pachet: Această linie ne permite să creăm fișierul executabil. dacă [$? -ne 0]; apoi ecou „A apărut o eroare! Anularea executării scriptului … „ieșirea 1

Pasul 7
Cu aceste linii va fi afișat un mesaj de eroare în cazul în care construcția executabilă este greșită.

Pasul 8
Odată ce introducem aceste informații, salvăm modificările folosind combinația de taste

Ctrl + O

și lăsăm editorul folosind

Ctrl + X

Pasul 9
Vom atribui permisiunile pentru ca scriptul să fie executabil folosind următoarea linie:

 chmod + x go-executable-build.bash

Pasul 10
Ultimul pas va fi testarea configurației scriptului executând următoarele. După cum putem vedea, nu a fost generată nicio eroare.

 ./go-executable-build.bash github.com/mholt/caddy/caddy 

8. Cum se verifică fișierele executabile în Ubuntu 17

Pentru a verifica dacă avem executabile corecte în Go, trebuie doar să executați următoarea linie:

 ls caddy *

Acolo vom vedea atât executabilele pe 32 de biți, cât și pe 64 de biți pentru sistemul selectat, în acest caz Windows. Dacă dorim să folosim alte platforme, trebuie doar să accesăm scriptul și să facem modificările în linie platforme.

Am văzut cum Go este o aplicație fundamentală atunci când este necesar să existe mai mulți executabili, facilitând gestionarea și distribuirea acestora în organizație.