Como criar executáveis ​​GO no Ubuntu 17

Um dos sistemas operacionais mais versáteis em Linux É sem dúvida o Ubuntu que, graças às suas funcionalidades, nos oferece um ambiente seguro e altamente configurável.

Além dessa grande vantagem, podemos encontrar inúmeras ferramentas e aplicativos que permitem aumentar os níveis de desempenho e produtividade oferecidos pela Ubuntu e com base nesta possibilidade analisaremos hoje uma ferramenta que nos oferece a possibilidade de criar arquivos executáveis ​​de vários sistemas operacionais para depois serem executados com total confiança, esta ferramenta se chama Ir.

O que é GOGo é um aplicativo de código aberto que nos permite criar software simples, confiável e altamente produtivo.

Go foi projetado com um grande portfólio de ferramentas que permitem obter pacotes e criar executáveis ​​de forma prática.

Com Go, como administradores de sistema, teremos a capacidade de criar executáveis ​​para vários sistemas operacionais e gerenciar todos eles a partir de um único servidor, sem a necessidade de ir a cada plataforma para baixar o executável correspondente.

Com Go podemos criar executáveis ​​para Windows, Linux, Mac OS, entre outros.

Antes de continuar a ver como criar o executável, faremos uma breve revisão de como instalar o Go no Ubuntu 17.

1. Como instalar e atualizar o sistema Ubuntu 17

Passo 1
A primeira etapa a realizar é executar os seguintes comandos para atualizar os pacotes do sistema e suas respectivas correções de bugs:

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

Passo 2
Assim que o sistema for atualizado, procedemos ao download dos respectivos binários Go executando a seguinte linha:

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

PROLONGAR

ObservaçãoCaso necessite dos binários para as edições de 32 bits, podemos acessar o seguinte link:

etapa 3
Após o download do arquivo, procedemos à sua extração executando a seguinte linha:

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

PROLONGAR

Passo 4
Vamos mover o conteúdo para o caminho / usr / local:

 sudo mv go / usr / local

2. Como ajustar o ambiente Go Ubuntu 17

Passo 1
Para que Go funcione corretamente, precisaremos inserir as seguintes linhas associadas ao caminho e acesso de Go:

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

PROLONGAR

Passo 2
É importante observar que o caminho GOPATH é onde os arquivos de construção serão hospedados.
Feito isso, podemos executar os seguintes comandos para verificar a versão e o ambiente do Go:

 versão go go env

PROLONGAR

etapa 3
Com isso já instalamos o Go e podemos prosseguir com a criação dos executáveis.
Deve-se notar que Go versão 1.8 está atualmente em beta, mas se quisermos instalá-lo, podemos executar os seguintes comandos:

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

3. Como baixar o código fonte no Ubuntu 17

Esta é a etapa inicial antes de criar qualquer executável com Go, obtendo seu código-fonte que obtemos usando o parâmetro go get.

O processo inclui clonando os pacotes no caminho GOPATH / src / e mais tarde, se você aplicá-los, eles serão construídos no caminho GOPATH / bin.

Passo 1
A sintaxe a ser usada para baixar o código-fonte é:

 vá buscar (caminho do pacote)

O caminho geralmente é encontrado na base do Github. Também adicionaremos o parâmetro -ou que instala todas as dependências ou a atualização delas.

Passo 2
Para este caso usaremos o Caddy que é um servidor web escrito em Go e executaremos a seguinte linha para baixá-lo:

 vá buscar -u github.com/mholt/caddy/caddy

etapa 3
Como podemos ver, nenhum resultado visível é exibido, mas todo o conteúdo será armazenado no caminho

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

Se quisermos verificar, podemos executar a linha qual caddie. Em alguns casos, Erros associados ao Git, para isso iremos executar o seguinte para a sua correção:

 sudo apt install git

4. Como construir o executável no Ubuntu 17

Passo 1
Uma vez que o Caddy tenha sido baixado e para isso, vamos executar a seguinte linha:

 vá construir github.com/mholt/caddy/caddy 

Passo 2
Este comando também não exibirá nenhum resultado visível. Se quisermos especificar uma rota especial, podemos adicionar o parâmetro -o da seguinte maneira. Podemos mudar a rota build / caddy-server para o desejado. Este comando irá criar o arquivo executável e aliás, se ele não existir, o diretório ./Construir.

 go build -o build / caddy-server github.com/mholt/caddy/caddy 

5. Como instalar o executável no Ubuntu 17

A instalação de um executável consiste em crie o arquivo .exe e armazene-o no Caminho GOPATH / bin. Para este processo usaremos o comando vá instalar que criará o executável no local correto.

Vamos executar o seguinte. Ao executar o comando, nenhum resultado será visível para o usuário, mas o arquivo terá sido criado no caminho GOPATH / bin.

 vá instalar github.com/mholt/caddy/caddy 

6. construir executáveis ​​para vários sistemas no Ubuntu 17

Neste ponto veremos o poder do Go e como ele se torna um aliado valioso graças às múltiplas possibilidades de criação de executáveis.

Passo 1
A sintaxe a ser implementada será a seguinte. O comando env é responsável por criar um ambiente modificado para o uso das respectivas variáveis.

 env GOOS = Objetivo do sistema operacional GOARCH = Arquitetura ir construir caminho do pacote 

Passo 2
A seguir está uma tabela com todas as opções que Go nos oferece:

etapa 3
Neste caso, criaremos um executável Windows com arquitetura amd de 64 bits, executaremos o seguinte:

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

Como é habitual em Go, não veremos nenhum resultado visível, mas o processo foi realizado internamente.

Passo 4
Isso criará o arquivo .exe com base no sistema escolhido e para verificá-lo executaremos a seguinte linha:

 ls caddy.exe 

7. Como criar o script para compilação de plataforma cruzada no Ubuntu 17

Com este objetivo criaremos um script chamado go-executable-build.bash que será um script responsável por realizar todas as ações de compilação de forma prática e pode ser usado em um nível geral com total compatibilidade.

Passo 1
Para isso, usaremos o linha cd ~ e vamos executar o seguinte:

 nano go-executable-build.bash

Passo 2
Devemos inserir as seguintes informações:

 #! / usr / bin / env bash package = $ 1 if [[-z "$ package"]]; então echo "uso: $ 0" exit 1 fi package_split = ($ {package // \ //}) package_name = $ {package_split [-1]} plataforma = ("windows / amd64" "windows / 386" "darwin / amd64 ") para a plataforma em" $ {platform_split [@]} "do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} output_name = $ package_name '-' $ GOOS '-' $ GOARCH if [$ GOOS = "windows"]; then output_name + = '. exe' fi env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ package if [$? -ne 0]; then echo 'Ocorreu um erro! Abortando a execução do script… 'exit 1 fi done

etapa 3
Este será o script e sua função é a seguinte:

 #! / usr / bin / env bash: Esta linha indica que o interpretador irá analisar o script. 

 pacote = $ 1: Esta linha pegará o primeiro argumento da linha de comando e o armazenará em sua variável. if [[-z "$ pacote"]]; em seguida, echo "uso: $ 0" saída 1 fi

Passo 4
Estas linhas se encarregam de mostrar uma mensagem caso o valor não seja informado.
Parâmetro E se analisa o valor da variável pacote.

 package_split = ($ {package // \ //}): Esta linha divide o caminho de importação do pacote em uma matriz usando o delimitador /. package_name = $ {package_split [-1]}: Esta linha leva o nome do array. plataformas = ("windows / amd64" "windows / 386" "darwin / amd64"): Lá entraremos o sistema operacional e a arquitetura a ser criada. para plataforma em "$ {platform_split [@]}" do platform_split = ($ {platform // \ //}) GOOS = $ {platform_split [0]} GOARCH = $ {platform_split [1]} Concluído

Etapa 5
Essas linhas dividem os valores da plataforma nas variáveis ​​GOOS e GOARCH.

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

Etapa 6
Com esta sequência iremos criar o nome do executável e quando se tratar de sistemas operacionais Windows devemos adicionar a extensão .exe.

 env GOOS = $ GOOS GOARCH = $ GOARCH go build -o $ output_name $ package: Esta linha nos permite criar o arquivo executável. se [$? -ne 0]; then echo 'Ocorreu um erro! Abortando a execução do script… 'exit 1

Etapa 7
Com essas linhas, uma mensagem de erro será exibida caso a construção do executável esteja incorreta.

Etapa 8
Depois de inserir essas informações, salvamos as alterações usando a combinação de teclas

Ctrl + O

e deixamos o editor usando

Ctrl + X

Etapa 9
Atribuiremos as permissões para que o script seja executável usando a seguinte linha:

 chmod + x go-executable-build.bash

Etapa 10
A última etapa será testar a configuração do script executando o seguinte. Como podemos ver, nenhum erro foi gerado.

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

8. Como verificar arquivos executáveis ​​no Ubuntu 17

Para verificar se temos os executáveis ​​corretos em Go, basta executar a seguinte linha:

 ls caddy *

Lá veremos os executáveis ​​de 32 bits e de 64 bits para o sistema selecionado, neste caso o Windows. Se quisermos usar outras plataformas, basta acessar o script e fazer as alterações na linha plataformas.

Vimos como o Go é uma aplicação fundamental quando é necessário ter múltiplos executáveis, facilitando o gerenciamento e distribuição destes na organização.