Base de Conhecimento

Introdução

Até o momento, em nossa série Como codificar no Go , você usou o comando go runpara compilar automaticamente seu código-fonte e executar o executável resultante. Embora este comando seja útil para testar seu código na linha de comando, distribuir ou implantar seu aplicativo exige que você construa seu código em um executável binário compartilhável ou em um único arquivo contendo código de byte da máquina que possa executar seu aplicativo. Para fazer isso, você pode usar a cadeia de ferramentas Go para criar e instalar seu programa.

No Go, o processo de conversão do código-fonte em um executável binário é chamado de construção . Uma vez que este executável é construído, ele conterá não apenas seu aplicativo, mas também todo o código de suporte necessário para executar o binário na plataforma de destino. Isto significa que um binário Go não precisa de sistema de dependências, como Go ferramentas para executar em um novo sistema, ao contrário de outras linguagens como rubi , Python , ou Node.js . Colocar esses executáveis ​​em um caminho de arquivo executável em seu próprio sistema permitirá executar o programa em qualquer lugar do sistema. Isso é chamado de instalação do programa no seu sistema.

Neste tutorial, você usará a cadeia de ferramentas Go para executar, construir e instalar um Hello, World!programa de amostra , permitindo usar, distribuir e implantar aplicativos futuros com eficiência.

Pré-requisitos

Para seguir o exemplo neste artigo, você precisará:

• Um espaço de trabalho do Go configurado seguindo Como instalar o Go e configurar um ambiente de programação local .

Configurando e executando o binário Go

Primeiro, crie um aplicativo para usar como exemplo para demonstrar a cadeia de ferramentas Go. Para fazer isso, você usará o clássico programa "Olá, Mundo!" Do tutorial Como escrever seu primeiro programa no Go .

Crie um diretório chamado greeterem seu srcdiretório:

• mkdir greeter

Em seguida, vá para o diretório recém-criado e crie o main.goarquivo no editor de texto de sua escolha:

• cd greeter
• nano main.go

Depois que o arquivo estiver aberto, adicione o seguinte conteúdo:

package main

import "fmt"

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

Quando executado, este programa imprime a frase Hello, World!no console e, em seguida, o programa é encerrado com êxito.

Salve e saia do arquivo.

Para testar o programa, use o go runcomando, como você fez nos tutoriais anteriores:

• go run main.go

Você receberá a seguinte saída:

Hello, World!

Como mencionado anteriormente, o go runcomando transformou seu arquivo de origem em um binário executável e, em seguida, executou o programa compilado. No entanto, este tutorial tem como objetivo construir o binário de forma que você possa compartilhá-lo e distribuí-lo à vontade. Para fazer isso, você usará o go buildcomando na próxima etapa.

Criando binários Go With go build

Usando go build, você pode gerar um binário executável para nosso aplicativo Go de amostra, permitindo distribuir e implantar o programa onde desejar.

Tente isso com main.go. No seu greeterdiretório, execute o seguinte comando:

• go build

Se você não fornecer um argumento para este comando, go buildo main.goprograma será compilado automaticamente em seu diretório atual. O comando incluirá todos os seus *.goarquivos no diretório Ele também criará todo o código de suporte necessário para poder executar o binário em qualquer computador com a mesma arquitetura de sistema, independentemente de esse sistema ter os .goarquivos de origem ou até uma instalação Go.

Nesse caso, você greetertransformou seu aplicativo em um arquivo executável que foi adicionado ao seu diretório atual. Verifique isso executando o lscomando:

• ls

Se você estiver executando o macOS ou Linux, encontrará um novo arquivo executável que recebeu o nome do diretório em que criou o seu programa:

greeter  main.go

Nota: No Windows, seu executável será greeter.exe.

Por padrão, go buildirá gerar um executável para a plataforma e a arquitetura atuais . Por exemplo, se criado em um linux/386sistema, o executável será compatível com qualquer outro linux/386sistema, mesmo que o Go não esteja instalado. O Go suporta a criação de outras plataformas e arquiteturas, sobre as quais você pode ler mais em nosso artigo Criando aplicativos de Go para diferentes sistemas operacionais e arquiteturas .

Agora, que você criou seu executável, execute-o para garantir que o binário tenha sido construído corretamente. No macOS ou Linux, execute o seguinte comando:

• ./greeter

No Windows, execute:

• greeter.exe

A saída do binário corresponderá à saída de quando você executou o programa com go run:

Hello, World!

Agora você criou um único binário executável que contém, não apenas o seu programa, mas também todo o código do sistema necessário para executar esse binário. Agora você pode distribuir esse programa para novos sistemas ou implantá-lo em um servidor, sabendo que o arquivo sempre executará o mesmo programa.

Na próxima seção, este tutorial explicará como um binário é nomeado e como você pode alterá-lo, para que você possa ter um melhor controle sobre o processo de compilação do seu programa.

Alterando o nome binário

Agora que você sabe como gerar um executável, a próxima etapa é identificar como o Go escolhe um nome para o binário e personalizar esse nome para o seu projeto.

Quando você executa go build, o padrão é que o Go decida automaticamente o nome do executável gerado. Isso é feito de duas maneiras: Se você estiver usando os Módulos Go , o Go usará a última parte do nome do seu módulo; caso contrário, o Go usará o nome do diretório atual. Este é o método usado na última seção, quando você criou o greeterdiretório, mudou para ele e depois executou go build.

Vamos dar uma olhada no método do módulo. Se você tinha um go.modarquivo em seu projeto com uma moduledeclaração como a seguinte:

module github.com/sammy/shark

Em seguida, o nome padrão para o executável gerado seria shark.

Em programas mais complexos que exigem convenções de nomenclatura específicas, esses valores padrão nem sempre são a melhor opção para nomear seu binário. Nesses casos, seria melhor personalizar sua saída com o -osinalizador.

Para testar isso, altere o nome do executável que você criou na última seção para helloe coloque-o em uma subpasta chamada bin. Você não precisa criar esta pasta; O Go fará isso por conta própria durante o processo de compilação.

Execute o seguinte go buildcomando com o -osinalizador:

• go build -o bin/hello

A -osinalização faz Go corresponder a saída do comando ao argumento que você escolher. Nesse caso, o resultado é um novo executável nomeado helloem uma subpasta denominada bin.

Para testar o novo executável, mude para o novo diretório e execute o binário:

• cd bin
• ./hello

Você receberá a seguinte saída:

Hello, World!

Agora você pode personalizar o nome do seu executável para atender às necessidades do seu projeto, completando nossa pesquisa sobre como criar binários no Go. Mas com go build, você ainda está limitado a executar seu binário no diretório atual. Para usar executáveis ​​recém-criados de qualquer lugar no seu sistema, você pode instalá-lo usando go install.

Instalando os programas Go com go install

Até agora neste artigo, discutimos como gerar binários executáveis ​​a partir de nossos .goarquivos de origem. Esses executáveis ​​são úteis para distribuir, implantar e testar, mas ainda não podem ser executados fora dos diretórios de origem. Isso seria um problema se você quisesse usar ativamente seu programa, como se você tivesse desenvolvido uma ferramenta de linha de comando para ajudar seu fluxo de trabalho em seu próprio sistema. Para facilitar o uso dos programas, você pode instalá-los no seu sistema e acessá-los de qualquer lugar.

Para entender o que isso significa, você usará o go installcomando para instalar seu aplicativo de amostra.

O go installcomando se comporta quase de forma idêntica go build, mas, em vez de deixar o executável no diretório atual ou em um diretório especificado pelo -osinalizador, ele coloca o executável no $GOPATH/bindiretório.

Para descobrir onde seu $GOPATHdiretório está localizado, execute o seguinte comando:

• go env GOPATH

A saída que você recebe varia, mas o padrão é o godiretório dentro do seu $HOMEdiretório:

$HOME/go

Como go installcolocará os executáveis ​​gerados em um subdiretório $GOPATHnomeado bin, esse diretório deverá ser adicionado à $PATHvariável de ambiente. Isso é abordado na etapa Criando sua área de trabalho do Go do artigo de pré-requisito Como instalar o Go e configurar um ambiente de programação local .

Com o $GOPATH/bindiretório configurado, volte para o seu greeterdiretório:

• cd ..

Agora execute o comando de instalação:

• go install

Isto irá construir o seu binário e colocá-lo em $GOPATH/bin. Para testar isso, execute o seguinte:

• ls $GOPATH/bin

Isso listará o conteúdo de $GOPATH/bin:

greeter

Nota: O go installcomando não suporta o -osinalizador, portanto, usará um dos nomes padrão descritos anteriormente para nomear o executável.

Com o binário instalado, teste para verificar se o programa será executado fora do diretório de origem. Volte para o diretório inicial:

• cd $HOME

Use o seguinte para executar o programa:

• greeter

Isso produzirá o seguinte:

Hello, World!

Agora você pode pegar os programas que você escreve e instalá-los em seu sistema, permitindo usá-los de onde e quando precisar.

Conclusão

Neste tutorial, você demonstrou como a cadeia de ferramentas Go facilita a criação de binários executáveis ​​a partir do código-fonte. Esses binários podem ser distribuídos para execução em outros sistemas, mesmo aqueles que não possuem ferramentas e ambientes Go. Você também costumava go installcriar e instalar automaticamente nossos programas como executáveis ​​no sistema $PATH. Com go builde go install, agora você pode compartilhar e usar seu aplicativo à vontade.