One place for hosting & domains

      compilar

      Como compilar um aplicativo Node.js com o Docker [Início rápido]


      Introdução

      Este tutorial traz um passo a passo para ajudá-lo na criação de uma imagem de aplicativo para um website estático que utilize o framework Express e o Bootstrap. Em seguida, você irá compilar um contêiner usando essa imagem, irá enviá-la para o Docker Hub e a utilizará para compilar outro contêiner, demonstrando como é possível recriar e dimensionar o seu aplicativo.

      Para obter uma versão mais detalhada deste tutorial, com explicações mais detalhadas de cada passo, consulte o tutorial Como compilar um aplicativo Node.js com o Docker.

      Pré-requisitos

      Para seguir este tutorial, você vai precisar do seguinte:

      • Um usuário sudo em seu servidor ou em seu ambiente local.
      • O Docker.
      • Node.js e npm.
      • Uma conta do Docker Hub.

      Passo 1 — Instalando as dependências do seu aplicativo

      Primeiro, crie um diretório para seu projeto em seu diretório home do usuário não raiz:

      Navegue até este diretório:

      Esse será o diretório raiz do projeto.

      Em seguida, crie um package.json com as dependências do seu projeto:

      Adicione as seguintes informações sobre o projeto ao arquivo; certifique-se de substituir as informações do autor pelo seu nome e detalhes de contato:

      ~/node_project/package.json

      {
        "name": "nodejs-image-demo",
        "version": "1.0.0",
        "description": "nodejs image demo",
        "author": "Sammy the Shark <sammy@example.com>",
        "license": "MIT",
        "main": "app.js",
        "scripts": {
          "start": "node app.js",
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "nodejs",
          "bootstrap",
          "express"
        ],
        "dependencies": {
          "express": "^4.16.4"
        }
      }
      

      Instale as dependências do seu projeto:

      Passo 2 — Criando os arquivos do aplicativo

      Criaremos um site que fornece informações aos usuários sobre tubarões.

      Abra o app.js no diretório principal do projeto para definir as rotas do projeto:

      Adicione o conteúdo a seguir ao arquivo para criar o aplicativo Express e os objetos Router, definir o diretório base, a porta e o host como variáveis, definir as rotas e, em seguida, montar o middleware router junto com os ativos estáticos do aplicativo:

      ~/node_project/app.js

      var express = require("express");
      var app = express();
      var router = express.Router();
      
      var path = __dirname + '/views/';
      
      // Constants
      const PORT = 8080;
      const HOST = '0.0.0.0';
      
      router.use(function (req,res,next) {
        console.log("/" + req.method);
        next();
      });
      
      router.get("/",function(req,res){
        res.sendFile(path + "index.html");
      });
      
      router.get("/sharks",function(req,res){
        res.sendFile(path + "sharks.html");
      });
      
      app.use(express.static(path));
      app.use("/", router);
      
      app.listen(8080, function () {
        console.log('Example app listening on port 8080!')
      })
      

      Em seguida, vamos adicionar conteúdo estático ao aplicativo. Crie o diretório views:

      Abra o index.html:

      Adicione o código a seguir ao arquivo, que importará o Boostrap e criará um componente jumbotron com um link para a página de informações mais detalhadas do sharks.html:

      ~/node_project/views/index.html

      <!DOCTYPE html>
      <html lang="en">
         <head>
            <title>About Sharks</title>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
            <link href="css/styles.css" rel="stylesheet">
            <link href='https://fonts.googleapis.com/css?family=Merriweather:400,700' rel='stylesheet' type='text/css'>
            <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
            <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
         </head>
         <body>
            <nav class="navbar navbar-inverse navbar-static-top">
               <div class="container">
                  <div class="navbar-header">
                     <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                     <span class="sr-only">Toggle navigation</span>
                     <span class="icon-bar"></span>
                     <span class="icon-bar"></span>
                     <span class="icon-bar"></span>
                     </button>
                     <a class="navbar-brand" href="https://www.digitalocean.com/#">Everything Sharks</a>
                  </div>
                  <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                     <ul class="nav navbar-nav mr-auto">
                        <li class="active"><a href="/">Home</a></li>
                        <li><a href="http://www.digitalocean.com/sharks">Sharks</a></li>
                     </ul>
                  </div>
               </div>
            </nav>
            <div class="jumbotron">
               <div class="container">
                  <h1>Want to Learn About Sharks?</h1>
                  <p>Are you ready to learn about sharks?</p>
                  <br>
                  <p><a class="btn btn-primary btn-lg" href="http://www.digitalocean.com/sharks" role="button">Get Shark Info</a></p>
               </div>
            </div>
            <div class="container">
               <div class="row">
                  <div class="col-md-6">
                     <h3>Not all sharks are alike</h3>
                     <p>Though some are dangerous, sharks generally do not attack humans. Out of the 500 species known to researchers, only 30 have been known to attack humans.</p>
                  </div>
                  <div class="col-md-6">
                     <h3>Sharks are ancient</h3>
                     <p>There is evidence to suggest that sharks lived up to 400 million years ago.</p>
                  </div>
               </div>
            </div>
         </body>
      </html>
      

      Em seguida, abra um arquivo chamado sharks.html:

      Adicione o código a seguir, o qual importará o Bootstrap e a folha de estilos personalizada e fornecerá informações detalhadas sobre certos tubarões:

      ~/node_project/views/sharks.html

      <!DOCTYPE html>
      <html lang="en">
         <head>
            <title>About Sharks</title>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
            <link href="css/styles.css" rel="stylesheet">
            <link href='https://fonts.googleapis.com/css?family=Merriweather:400,700' rel='stylesheet' type='text/css'>
            <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
            <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
         </head>
         <nav class="navbar navbar-inverse navbar-static-top">
            <div class="container">
               <div class="navbar-header">
                  <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                  <span class="sr-only">Toggle navigation</span>
                  <span class="icon-bar"></span>
                  <span class="icon-bar"></span>
                  <span class="icon-bar"></span>
                  </button>
                  <a class="navbar-brand" href="https://www.digitalocean.com/#">Everything Sharks</a>
               </div>
               <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                  <ul class="nav navbar-nav mr-auto">
                     <li><a href="/">Home</a></li>
                     <li class="active"><a href="http://www.digitalocean.com/sharks">Sharks</a></li>
                  </ul>
               </div>
            </div>
         </nav>
         <div class="jumbotron text-center">
            <h1>Shark Info</h1>
         </div>
         <div class="container">
            <div class="row">
               <div class="col-md-6">
                  <p>
                  <div class="caption">Some sharks are known to be dangerous to humans, though many more are not. The sawshark, for example, is not considered a threat to humans.</div>
                  <img src="https://assets.digitalocean.com/articles/docker_node_image/sawshark.jpg" alt="Sawshark">
                  </p>
               </div>
               <div class="col-md-6">
                  <p>
                  <div class="caption">Other sharks are known to be friendly and welcoming!</div>
                  <img src="https://assets.digitalocean.com/articles/docker_node_image/sammy.png" alt="Sammy the Shark">
                  </p>
               </div>
            </div>
          </div>
         </body>
      </html>
      

      Por fim, crie a folha de estilos CSS personalizada que você vinculou ao index.html e ao sharks.html, criando primeiro uma pasta css no diretório views:

      Abra a folha de estilos e adicione o código a seguir, o qual definirá a cor e a fonte desejadas para nossas páginas:

      ~/node_project/views/css/styles.css

      .navbar {
              margin-bottom: 0;
      }
      
      body {
              background: #020A1B;
              color: #ffffff;
              font-family: 'Merriweather', sans-serif;
      }
      h1,
      h2 {
              font-weight: bold;
      }
      p {
              font-size: 16px;
              color: #ffffff;
      }
      
      
      .jumbotron {
              background: #0048CD;
              color: white;
              text-align: center;
      }
      .jumbotron p {
              color: white;
              font-size: 26px;
      }
      
      .btn-primary {
              color: #fff;
              text-color: #000000;
              border-color: white;
              margin-bottom: 5px;
      }
      
      img, video, audio {
              margin-top: 20px;
              max-width: 80%;
      }
      
      div.caption: {
              float: left;
              clear: both;
      }
      

      Inicie o aplicativo:

      Use seu navegador para ir para o endereço http://your_server_ip:8080 ou localhost:8080, se estiver trabalhando localmente. Você verá a seguinte página inicial:

      Página inicial do aplicativo

      Clique no botão Get Shark Info. Você verá a seguinte página de informações:

      Página de informações sobre tubarões

      Agora, você tem um aplicativo em funcionamento. Quando estiver pronto, saia do servidor, digitando CTRL+C.

      Passo 3 — Escrevendo o Dockerfile

      No diretório raiz do seu projeto, crie o Dockerfile:

      Adicione o código a seguir ao arquivo:

      ~/node_project/Dockerfile

      
      FROM node:10-alpine
      
      RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
      
      WORKDIR /home/node/app
      
      COPY package*.json ./
      
      USER node
      
      RUN npm install
      
      COPY --chown=node:node . .
      
      EXPOSE 8080
      
      CMD [ "node", "app.js" ]
      

      Esse Dockerfile utiliza uma imagem base alpine, assegurando que o usuário node não raiz detenha a propriedade dos arquivos do aplicativo. Por padrão, a imagem Node do Docker inclui o usuário node não raiz.

      Em seguida, adicione seus módulos node locais, os registros npm, o Dockerfile e o .dockerignore ao seu arquivo .dockerignore:

      ~/node_project/.dockerignore

      node_modules
      npm-debug.log
      Dockerfile
      .dockerignore
      

      Compile a imagem do aplicativo usando o comando docker build:

      • docker build -t your_dockerhub_username/nodejs-image-demo .

      O . especifica que o contexto de compilação é o diretório atual.

      Verifique suas imagens:

      Você verá o seguinte resultado:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 8 seconds ago 895MB node 10 f09e7c96b6de 17 hours ago 893MB

      Execute o comando a seguir para compilar um contêiner usando esta imagem:

      • docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

      Usando o docker ps, verifique a lista dos contêineres em execução:

      Você verá o seguinte resultado:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e50ad27074a7 your_dockerhub_username/nodejs-image-demo "npm start" 8 seconds ago Up 7 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

      Com seu contêiner em execução, agora você pode acessar o seu aplicativo, utilizando seu navegador para acessar o endereço http://your_server_ip ou o localhost. Você verá a página inicial do seu aplicativo novamente:

      Página inicial do aplicativo

      Agora que você criou uma imagem para seu aplicativo, é possível encaminhá-la para o Docker Hub para uso futuro.

      O primeiro passo para enviar a imagem é fazer o login na sua conta do Docker Hub:

      • docker login -u your_dockerhub_username -p your_dockerhub_password

      Acessar dessa maneira criará um arquivo ~/.docker/config.json no diretório home do seu usuário, com as suas credenciais do Docker Hub.

      Envie sua imagem, usando seu próprio nome de usuário no lugar de your_dockerhub_username:

      • docker push your_dockerhub_username/nodejs-image-demo

      Se quiser, teste o utilitário do registro de imagens, destruindo o contêiner e a imagem atuais do seu aplicativo; depois, recompile-os.

      Primeiro, liste os contêineres em execução:

      Você verá o seguinte resultado:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e50ad27074a7 your_dockerhub_username/nodejs-image-demo "npm start" 3 minutes ago Up 3 minutes 0.0.0.0:80->8080/tcp nodejs-image-demo

      Usar o CONTAINER ID listada em sua saída interromperá o contêiner do aplicativo em execução. Certifique-se de substituir o ID destacado abaixo pelo seu próprio CONTAINER ID:

      Liste todas as suas imagens com o sinalizador -a:

      Você verá o seguinte resultado com o nome de sua imagem, your_dockerhub_username/nodejs-image-demo, junto com a imagem node e outras imagens da sua compilação:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 7 minutes ago 895MB <none> <none> e039d1b9a6a0 7 minutes ago 895MB <none> <none> dfa98908c5d1 7 minutes ago 895MB <none> <none> b9a714435a86 7 minutes ago 895MB <none> <none> 51de3ed7e944 7 minutes ago 895MB <none> <none> 5228d6c3b480 7 minutes ago 895MB <none> <none> 833b622e5492 8 minutes ago 893MB <none> <none> 5c47cc4725f1 8 minutes ago 893MB <none> <none> 5386324d89fb 8 minutes ago 893MB <none> <none> 631661025e2d 8 minutes ago 893MB node 10 f09e7c96b6de 17 hours ago 893MB

      Usando o comando abaixo, remova o contêiner suspenso e todas as imagens, incluindo as imagens não utilizadas ou pendentes:

      Com todas as suas imagens e contêineres excluídos, agora você poderá extrair a imagem do aplicativo do Docker Hub:

      • docker pull your_dockerhub_username/nodejs-image-demo

      Liste as suas imagens novamente:

      Você verá a imagem do seu aplicativo:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 11 minutes ago 895MB

      Agora, você pode recompilar seu contêiner, usando o comando do Passo 3:

      • docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

      Liste seus contêineres em execução:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES f6bc2f50dff6 your_dockerhub_username/nodejs-image-demo "npm start" 4 seconds ago Up 3 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

      Acesse novamente o http://your_server_ip ou o localhost para visualizar seu aplicativo em execução.

      Tutoriais relacionados

      Aqui estão os links para os guias mais detalhados relacionados a este tutorial:

      Você também pode revisar a série mais extensa do artigo intitulado De contêineres a Kubernetes com o Node.js, a partir da qual este tutorial foi adaptado.

      Além disso, consulte nossa biblioteca completa dos Recursos do Docker para obter mais detalhes sobre o Docker.



      Source link

      Como compilar e instalar programas em Go


      Introdução

      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.

      Pré-requisitos

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

      Configurando e executando o binário do Go

      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:

      Em seguida, mova-o para o diretório recém-criado e crie o arquivo main.go no editor de texto da sua escolha:

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

      src/greeter/main.go

      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:

      Você receberá o seguinte resultado:

      Output

      Hello, 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.

      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:

      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:

      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:

      Output

      greeter 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:

      No Windows, execute:

      O resultado do binário corresponderá ao resultado obtido quando você executou o programa com o go run:

      Output

      Hello, 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.

      Alterando o nome do binário

      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:

      go.mod

      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:

      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:

      Você receberá o seguinte resultado:

      Output

      Hello, 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.

      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:

      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:

      Agora, execute o comando de instalação:

      Isso irá compilar seu binário e colocar ele em $GOPATH/bin. Para testar isso, execute o seguinte:

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

      Output

      greeter

      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:

      Use o seguinte para executar o programa:

      Isso irá resultar no seguinte:

      Output

      Hello, World!

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

      Conclusão

      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.



      Source link