Até agora, em nossa série de artigos sobre Como codificar em Go, você usou o comando go run
para compilar automaticamente seu código fonte e executar o arquivo executável resultante. Embora esse comando seja útil para testar seu código na linha de comando, distribuir ou implantar, o seu aplicativo exige que você compile o seu código em um executável binário compartilhável ou em um único arquivo contendo um código de byte de máquina que possa executar seu aplicativo. Para tanto, utilize a cadeia de ferramentas do Go para compilar e instalar o seu programa.
No Go, o processo de tradução do código fonte em um executável binário é chamado de compilação. Assim que esse executável estiver compilado, ele terá que conter não apenas o seu aplicativo, mas também todo o código de suporte necessário para executar o binário na plataforma de destino. Isso significa que um binário do Go não precisa das dependências de sistema como as ferramentas do Go para executar em um novo sistema, ao contrário de outras linguagens como Ruby, Python, ou Node.js. Colocar esses executáveis em um caminho de arquivo executável em seu próprio sistema permitirá que você execute o programa de qualquer lugar em seu sistema. Esse procedimento é chamado de instalação do programa no sistema.
Neste tutorial, você usará a cadeia de ferramentas do Go para executar, compilar e instalar um programa exemplo Hello, World!
, permitindo que você use, distribua e implante aplicativos futuros de maneira eficaz.
Para seguir o exemplo neste artigo, você precisará de:
Primeiro, crie um aplicativo para usar como um exemplo para demonstrar a cadeia de ferramentas do Go. Para fazer isso, você usará o clássico programa “Hello, World!!” do tutorial Como escrever seu primeiro programa em Go.
Crie um diretório chamado greeter
em seu diretório src
:
- mkdir greeter
Em seguida, mova-o para o diretório recém-criado e crie o arquivo main.go
no editor de texto da sua escolha:
- cd greeter
- nano main.go
Assim que o arquivo estiver aberto, adicione o seguinte conteúdo:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Quando executar, esse programa imprimirá a frase Hello, World!
no console e, depois, o programa fechará com sucesso.
Salve e saia do arquivo.
Para testar o programa, utilize o comando go run
, como fez em tutoriais anteriores:
- go run main.go
Você receberá o seguinte resultado:
OutputHello, World!
Como mencionamos anteriormente, o comando go run
compilou o seu arquivo fonte em um binário executável e, em seguida, executou o programa compilado. Entretanto, o objetivo deste tutorial é compilar o binário de maneira a possibilitar que você o compartilhe e distribua à vontade. Para fazer isso, utilize o comando go build
no passo seguinte.
go build
Ao usar o go build
, você pode gerar um binário executável para nosso aplicativo exemplo em Go, permitindo que distribua e implante o programa onde quiser.
Experimente isso com main.go
. No seu diretório greeter
, execute o seguinte comando:
- go build
Se você não fornecer um argumento para esse comando, o go build
compilará automaticamente o programa main.go
em seu diretório atual. O comando incluirá todos os seus arquivos *.go
no diretório. Ele também compilará todo o código de suporte necessário para conseguir executar o binário em qualquer computador com a mesma arquitetura de sistema, independentemente do sistema ter os arquivos fonte .go
, ou mesmo uma instalação do Go.
Neste caso, você compilou seu aplicativo greeter
em um arquivo executável que foi adicionado ao seu diretório atual. Verifique isso executando o comando ls
:
- ls
Se estiver usando o macOS ou o Linux, você encontrará um novo arquivo executável que foi nomeado depois do diretório no qual você compilou o seu programa:
Outputgreeter main.go
Nota: no Windows, o seu executável será o greeter.exe
.
Por padrão, o go build
irá gerar um executável para a plataforma e arquitetura atuais. Por exemplo, se ele foi compilado em um sistema linux/386
, o executável será compatível com qualquer outro sistema linux/386
, mesmo se o Go não estiver instalado. O Go oferece suporte à compilação para outras plataformas e arquiteturas. Você pode ler mais a esse respeito em nosso artigo intitulado Compilando aplicativos em Go para diferentes sistemas operacionais e arquiteturas.
Agora que você criou seu executável, execute-o para garantir que o binário foi compilado corretamente. No macOS ou Linux, execute o seguinte comando:
- ./greeter
No Windows, execute:
- greeter.exe
O resultado do binário corresponderá ao resultado obtido quando você executou o programa com o go run
:
OutputHello, World!
Com isto, você criou um binário executável único que contém não apenas seu programa, mas também todo o código do sistema necessário para executar aquele binário. Agora, você já 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 irá explicar como nomear um binário e como modificá-lo, para que tenha um controle melhor sobre o processo de compilação do seu programa.
Agora que você sabe como gerar um executável, o próximo passo é identificar como o Go escolhe um nome para o binário e como personalizar esse nome para o seu projeto.
Ao executar o go build
, por padrão o Go decide automaticamente o nome do executável gerado. Ele faz isso em uma das duas maneiras: se estiver usando o Go Modules, então, o Go usará a última parte do nome do seu módulo; caso contrário, o Go usará o nome do diretório atual. Esse foi o método usado na última seção, quando você criou o diretório greeter
, transformou-o e, em seguida, executou o go build
.
Vamos examinar o método do módulo mais atentamente. Se você tivesse um arquivo go.mod
em seu projeto com uma declaração de module
como a seguinte:
module github.com/sammy/shark
Então, o nome padrão para o executável gerado seria shark
.
Em programas mais complexos que exijam convenções de nome específicas, esses valores padrão nem sempre serão a melhor escolha para nomear o seu binário. Nesses casos, seria melhor personalizar seu resultado com o sinalizador -o
.
Para testar isso, altere o nome do executável que você fez na última seção para hello e o
coloque em uma subpasta chamada bin
. Você não precisa criar essa pasta; o Go fará isso sozinho durante o processo de compilação.
Execute o seguinte comando go build
com o sinalizador -o
:
- go build -o bin/hello
O sinalizador -o
fará o Go corresponder o resultado do comando com o argumento que você tiver escolhido. Neste caso, o resultado seria um novo executável chamado hello
em uma subpasta chamada bin
.
Para testar o novo executável, faça a alteração no novo diretório e execute o binário:
- cd bin
- ./hello
Você receberá o seguinte resultado:
OutputHello, World!
Agora, é possível personalizar o nome de seu executável para atender às necessidades do seu projeto, completando nossa pesquisa de como compilar binários em Go. Com o go build
, porém, você ainda estará limitado a executar seu binário a partir do diretório atual. Para usar executáveis recém-compilados de qualquer lugar em seu sistema, instale-o usando o go install
.
go install
Até agora, neste artigo, discutimos sobre como gerar binários executáveis a partir de nossos arquivos fontes .go
. Esses executáveis são úteis para distribuir, implantar e testar, mas eles ainda não podem ser executados fora de seus diretórios fonte. Isto seria um problema caso você quisesse usar de maneira ativa seus programas, por exemplo, se 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 em seu sistema e acessá-los de qualquer lugar.
Para entender o que isso significa, você usará o comando go install
para instalar seu aplicativo exemplo.
O comando go install
se comporta quase da mesma forma que o go build
. Porém, em vez de deixar o executável no diretório atual, ou em um diretório especificado pelo sinalizador -o
, ele coloca o executável no diretório $GOPATH/bin
.
Para descobrir onde seu diretório $GOPATH
está localizado, execute o seguinte comando:
- go env GOPATH
O resultado que receber irá variar, mas o padrão é o diretório go
dentro do seu diretório $HOME
:
Output$HOME/go
Uma vez que o go install
irá colocar os executáveis gerados em um subdiretório $GOPATH
chamado de bin
, este diretório deve ser adicionado à variável de ambiente $PATH
. Isso está explicado no passo Criando seu espaço de trabalho em Go do artigo com os pré-requisitos de Como instalar o Go e configurar um ambiente de programação local.
Com o diretório $GOPATH/bin
configurado, volte para seu diretório greeter
:
- cd ..
Agora, execute o comando de instalação:
- go install
Isso irá compilar seu binário e colocar ele em $GOPATH/bin
. Para testar isso, execute o seguinte:
- ls $GOPATH/bin
Isso listará o conteúdo do $GOPATH/bin
:
Outputgreeter
Nota: o comando go install
não oferece suporte ao sinalizador -o
. Assim, ele irá usar um dos nomes padrão descritos anteriormente para nomear o executável.
Com o binário instalado, teste para ver se o programa executará fora de seu diretório fonte. Volte para seu diretório home:
- cd $HOME
Use o seguinte para executar o programa:
- greeter
Isso irá resultar no seguinte:
OutputHello, World!
Agora, você pode pegar os programas que escrever e instalá-los em seu sistema, permitindo que os utilize onde e quando precisar.
Neste tutorial, você demonstrou como a cadeia de ferramentas do Go torna fácil a compilação de binários executáveis do código fonte. Esses binários podem ser distribuídos para executar em outros sistemas, mesmo aqueles que não tenham as ferramentas e ambientes em Go. Você também usou o go install
para compilar e instalar automaticamente nossos programas como executáveis no $PATH
do sistema. Com o go build
e o go install
, agora você pode compartilhar e usar o seu aplicativo à vontade.
Agora que você sabe o básico sobre o go build
, você pode explorar mais a fundo sobre como tornar o código fonte modular, consultando o tutorial Personalizando binários em Go com build tags, ou sobre como compilar para diferentes plataformas, consultando o artigo Compilando aplicativos em Go para diferentes sistemas operacionais e arquiteturas. Se quiser aprender mais sobre a linguagem de programação Go em geral, confira nossa série de artigos sobre Como codificar em Go.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.