One place for hosting & domains

      Como instalar o Go e configurar um ambiente de programação local no Windows 10


      Introdução

      O Go é uma linguagem de programação que nasceu de frustrações no Google. Os desenvolvedores tinham que escolher continuamente entre uma linguagem eficaz na execução, mas que levava muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que não era eficaz na produção. A linguagem Go foi projetada para ter todas as três vantagens disponíveis ao mesmo tempo: velocidade de compilação, facilidade da programação e a eficiência da execução na produção.

      Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é adequada particularmente para programas de sistemas de rede/distribuídos e ganhou uma reputação como “a linguagem da nuvem”. Essa linguagem se dedica a ajudar o programador moderno a produzir mais com um conjunto forte de ferramentas, tirando de cena os debates sobre a formatação e fazendo da formatação parte das especificações da linguagem, além de tornar a implantação fácil por meio da compilação em um binário único. A linguagem Go é fácil de aprender, com uma série pequena de palavras-chave que a tornam uma ótima escolha tanto para desenvolvedores iniciantes, quanto para experientes.

      Este tutorial guiará você na instalação do Go em sua máquina local do Windows 10 e na configuração de um ambiente de programação através da linha de comando.

      Pré-requisitos

      Você precisará de uma máquina com Windows 10 – com acesso administrativo e conectada à Internet.

      Passo 1 — Abrindo e configurando o PowerShell

      Você concluirá a maior parte da instalação e configuração em uma interface de linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar em botões, você vai digitar em texto e receberá o feedback de seu computador por texto também. A linha de comando, também conhecida como shell, pode ajudar você a modificar e automatizar muitas das tarefas que você faz em um computador diariamente. Trata-se de uma ferramenta essencial para os desenvolvedores de software.

      O PowerShell é um programa da Microsoft que fornece uma interface de shell de linha de comando. As tarefas administrativas são realizadas executando cmdlets, pronunciadas command-lets, que são classes especializadas do . NET Framework (software), que pode realizar as operações. De código aberto em agosto de 2016, o PowerShell agora está disponível para uso entre as plataformas, tanto para sistemas em Windows, como em Unix (incluindo Mac e Linux).

      Para encontrar o Windows PowerShell, clique com o botão direito no ícone Start (Iniciar), no canto inferior esquerdo de sua tela. Quando o menu aparecer, clique em Search (Pesquisa) e, em seguida, digite PowerShell na barra de busca. Quando as opções forem exibidas para você, clique com o botão direito no Windows PowerShell do aplicativo Desktop. Para os fins deste tutorial, selecione Run as Administrator (Executar como administrador). Quando a caixa de diálogo surgir com a questão Do you want to allow this app to make changes to your PC? (Deseja permitir que este aplicativo faça alterações no seu computador?) clique em Yes (Sim).

      Assim que fizer isso, verá uma interface baseada em texto que tem uma string de palavras que se parece com esta:

      Windows 10 PowerShell

      Troque de pasta de sistema, digitando o seguinte comando:

      Então, você estará em um diretório home, como o PS C:Userssammy.

      Para continuar com o processo de instalação, primeiro você deve definir as permissões através do PowerShell. Configurado para executar no modo mais seguro por padrão, existem alguns níveis de permissões que você pode configurar como administrador:

      • Restricted (Restrita) é a política de execução padrão. Sob este modo, você não poderá executar scripts e o PowerShell funcionará apenas como uma shell interativa.
      • AllSigned (Todas Assinadas) permitirá que você execute todos os scripts e arquivos de configuração assinados por um fornecedor confiável, o que significa que possivelmente poderia abrir sua máquina para o risco de executar scripts maliciosos que podem ser assinados por um fornecedor confiável.
      • RemoteSigned (Assinatura Remota), permitirá que você execute scripts e arquivos de configuração baixados da Internet - assinados por fornecedores confiáveis, abrindo novamente sua máquina a vulnerabilidades se esses scripts confiáveis, na verdade, forem maliciosos.
      • Unrestricted (Irrestrito) executará todos os scripts e arquivos de configuração baixados da Internet desde que você confirme que entendeu que o arquivo foi baixado da Internet. Neste caso, não será necessária uma assinatura digital. Dessa maneira, você pode estar abrindo sua máquina para o risco de executar scripts não assinados e potencialmente maliciosos baixados da Internet.

      Neste tutorial, você usará a política de execução RemoteSigned para definir as permissões do usuário atual. Isso permitirá que o PowerShell aceite scripts confiáveis sem criar as permissões tão amplas quanto elas seriam com uma permissão Unrestricted. Digite o seguinte no PowerShell:

      • Set-ExecutionPolicy -Scope CurrentUser

      O PowerShell solicitará que você forneça uma política de execução. Digite o seguinte para usar o RemoteSigned:

      Assim que pressionar ENTER, será solicitado que confirme a mudança para a política de execução. Digite a letra y para permitir que as alterações entrem em vigor. Você pode confirmar se isso funcionou, solicitando as permissões atuais na máquina:

      • Get-ExecutionPolicy -List

      Você deve receber um resultado que se parece com este:

      Output

      Scope ExecutionPolicy ----- --------------- MachinePolicy Undefined UserPolicy Undefined Process Undefined CurrentUser RemoteSigned LocalMachine Undefined

      Isso confirma que o usuário atual pode executar scripts confiáveis baixados da Internet. Agora, você pode seguir em frente para baixar os arquivos que precisaremos para configurar nosso ambiente de programação em Go.

      Passo 2 — Instalando o gerenciador de pacotes Chocolatey

      Um gerenciador de pacotes é uma coleção de ferramentas de software que funcionam para automatizar processos de instalação. Isso inclui a instalação inicial, o upgrade e a configuração do software, bem como a remoção de software - conforme necessário. Eles mantêm as instalações de software em um local central e podem manter todos os pacotes de software no sistema, nos formatos em que são habitualmente usados.

      O Chocolatey é um gerenciador de pacotes de linha de comando criado para o Windows que funciona como o apt-get funciona no Linux. Disponível em uma versão de código aberto, o Chocolatey ajudará você a instalar aplicativos e ferramentas rapidamente. Você o usará para baixar o que for necessário para o seu ambiente de desenvolvimento.

      Antes de instalar o script, leia-o para confirmar que está satisfeito com as alterações que ele fará em sua máquina. Para fazer isso, use o framework de script .NET para baixar e exibir o script do Chocolatey na janela do seu terminal.

      Comece criando um objeto WebClient chamado $script que compartilha as configurações de conexão da Internet com o Internet Explorer:

      • $script = New-Object Net.WebClient

      Examine as opções disponíveis, canalizando o objeto $script com uma | para a classe Get-Member:

      Isso retornará todos os membros (propriedades e métodos) deste objeto WebClient:

      Snippet of Output

      . . . DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur... DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa... DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy... DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy… . . .

      Examinando o resultado, você consegue identificar o método DownloadString, usado para exibir o script e a assinatura na janela do PowerShell. Use este método para verificar o script:

      • $script.DownloadString("https://chocolatey.org/install.ps1")

      Após verificar o script, instale o Chocolatey, digitando o seguinte no PowerShell:

      • iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex

      O cmdlet iwr, ou Invoke-WebRequest, permite que você extraia dados da Web. Isso passará o script para iex, ou o cmdlet Invoke-Expression, que executará o conteúdo do script e a instalação para o gerenciador de pacotes Chocolatey.

      Permita que o PowerShell instale o Chocolatey. Assim que ele estiver totalmente instalado, comece a instalar as ferramentas adicionais com o comando choco.

      Se você precisar fazer o upgrade do Chocolatey no futuro, execute o seguinte comando:

      Com o gerenciador de pacotes instalado, instale o resto do que for necessário para o ambiente de programação em Go.

      Passo 3 — Instalando o editor de texto Nano (opcional)

      Neste passo, você instalará o nano, um editor de texto que usa uma interface de linha de comando. Você pode usar o nano para escrever programas diretamente dentro do PowerShell. Este não é um passo obrigatório, já que é possível usar um editor de texto com uma interface de usuário gráfica, como o Bloco de notas. Este tutorial recomenda que use o nano, uma vez que ele ajudará você a se acostumar a usar o PowerShell.

      Use o Chocolatey para instalar o nano:

      O identificador -y confirma automaticamente que você deseja executar o script, sem ser solicitado a confirmar.

      Assim que o nano estiver instalado, utilize o comando nano para criar novos arquivos de texto. Você usará isso mais tarde neste tutorial para escrever seu primeiro programa Go.

      Passo 4 — Instalando o Go

      Assim como fez com o nano no passo anterior, você usará o Chocolatey para instalar o Go:

      Nota: como o go é uma palavra muito pequena, tornou-se comum usar golang como um termo para instalar pacotes e procurar artigos relacionados ao Go na Internet. O termo Golang nasceu do domínio para a linguagem Go, que é o golang.org.

      O PowerShell instalará o Go, gerando resultados dentro do PowerShell durante o processo. Assim que a instalação for concluída, você deve ver o seguinte resultado:

      Output

      Environment Vars (like PATH) have changed. Close/reopen your shell to see the changes (or in powershell/cmd.exe just type `refreshenv`). The install of golang was successful. Software installed as 'msi', install location is likely default. Chocolatey installed 1/1 packages. See the log for details (C:ProgramDatachocolateylogschocolatey.log).

      Com a instalação finalizada, você agora confirmará que Go está instalado. Para ver as alterações, feche e abra novamente o PowerShell como administrador e, em seguida, verifique a versão do Go disponível em sua máquina local:

      Você receberá um resultado parecido com este:

      Output

      go version go1.12.1 windows/amd643.7.0

      Assim que o Go estiver instalado, você poderá configurar um espaço de trabalho para seus projetos de desenvolvimento.

      Passo 5 — Criando seu espaço de trabalho em Go

      Agora que você tem o Chocolatey, o nano e Go instalados, crie seu espaço de trabalho de programação.

      O espaço de trabalho em Go terá dois diretórios como sua raiz:

      • src: o diretório que contém os arquivos fonte do Go. Um arquivo fonte é um arquivo que você escreve usando a linguagem de programação Go. Os arquivos fonte são usados pelo compilador Go para criar um arquivo binário executável.
      • bin: o diretório que contém executáveis compilados e instalados pelas ferramentas do Go. Os executáveis são arquivos binários que são executados no seu sistema e executam tarefas. Esses são programas tipicamente compilados pelo seu código fonte ou outro código fonte baixado do Go.

      O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como o github.com ou golang.org quando seu programa importar bibliotecas de terceiros. Se estiver usando um repositório de códigos como o github.com, você também colocará seus projetos e arquivos fonte sob aquele diretório. Isso permite uma importação canônica do código no seu projeto. As importações Canônicas são importações que referenciam um pacote totalmente qualificado, como o github.com/digitalocean/godo.

      Aqui está como um espaço de trabalho típico se parece:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git repository metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      A partir da versão 1.8, o diretório padrão para o espaço de trabalho do Go é o seu diretório home de usuário com um subdiretório go, ou $HOME/go. Se estiver usando uma versão anterior à versão 1.8 do Go, ainda é considerada como melhor prática usar o local $HOME/go como o seu espaço de trabalho.

      Emita o comando seguinte para navegar até o diretório $HOME:

      Em seguida, crie a estrutura de diretório para seu espaço de trabalho do Go:

      Isso garantirá que a seguinte estrutura de diretório em funcionamento:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes do Go 1.8, era necessário definir uma variável local do ambiente chamada $GOPATH. Embora já não seja necessário fazer isso, ainda é considerada uma boa prática, já que muitas ferramentas de terceiros ainda precisam que seja definida.

      Como você usou o Chocolatey para a instalação, essa variável de ambiente já deverá estar definida. Verifique isso com o seguinte comando:

      Você deve ver o seguinte resultado, com seu nome de usuário no lugar de sammy:

      Output

      C:Userssammygo

      Quando o Go compila e instala ferramentas, ele as coloca no diretório $GOPATH/bin. Por conveniência, é comum adicionar o subdiretório bin do espaço de trabalho ao seu $PATH. É possível fazer isso usando o comando setx no PowerShell:

      • setx PATH "$($env:path);$GOPATHbin"

      Isso permitirá que você execute qualquer programa que compilar ou baixar através das ferramentas Go - em qualquer lugar em seu sistema.

      Agora que você tem a raiz do espaço de trabalho criada e sua variável de ambiente $GOPATH definida, crie seus projetos futuros com a seguinte estrutura de diretório. Este exemplo supõe que esteja usando o github.com como seu repositório:

      $GOPATH/src/github.com/username/project
      

      Se estivesse trabalhando no projeto https://github.com/digitalocean/godo, você o colocaria no seguinte diretório:

      $GOPATH/src/github.com/digitalocean/godo
      

      Estruturar seus projetos dessa maneira irá torná-los disponíveis com a ferramenta go get. Isso também ajudará mais adiante com a legibilidade.

      É possível verificar isso usando o comando go get para buscar a biblioteca godo:

      • go get github.com/digitalocean/godo

      Nota: se não tiver o git instalado, o Windows abrirá uma caixa de diálogo perguntando se deseja instalá-lo. Clique em Yes para continuar e siga as instruções de instalação.

      É possível ver se ele baixou corretamente o pacote godo, listando o diretório:

      • ls $env:GOPATH/src/github.com/digitalocean/godo

      Você receberá um resultado semelhante a este:

      Output

      Directory: C:Userssammygosrcgithub.comdigitaloceangodo Mode LastWriteTime Length Name ---- ------------- ------ ---- d----- 4/10/2019 2:59 PM util -a---- 4/10/2019 2:59 PM 9 .gitignore -a---- 4/10/2019 2:59 PM 69 .travis.yml -a---- 4/10/2019 2:59 PM 1592 account.go -a---- 4/10/2019 2:59 PM 1679 account_test.go -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -a---- 4/10/2019 2:59 PM 5076 vpcs.go -a---- 4/10/2019 2:59 PM 4309 vpcs_test.go

      Neste passo, você criou um espaço de trabalho em Go e configurou as variáveis do ambiente necessárias. No próximo passo, você testará o espaço de trabalho com algum código.

      Passo 6 — Criando um programa simples

      Agora que você tem o espaço de trabalho em Go configurado, crie um programa “Hello, World!” simples. Isso garantirá que seu espaço de trabalho fique devidamente configurado, bem como dará a você a oportunidade de se familiarizar com o Go. Como está criando um único arquivo fonte em Go e não um projeto real, você não precisa estar em seu espaço de trabalho para fazer isso.

      Do seu diretório home, abra um editor de texto de linha de comando, como o nano e crie um novo arquivo:

      Assim que o arquivo de texto abrir no nano, digite seu programa:

      hello.go

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

      Saia do nano, pressionando as teclas CTRL e X. Quando solicitado a salvar o arquivo, pressione Y e, então, ENTER.

      Esse código usará o pacote fmt e chamará a função Println com o Hello, World! como argumento. Isso fará a frase Hello, World! imprimir no terminal quando o programa for executado.

      Assim que sair do nano e retornar ao seu shell, execute o programa:

      O programa hello.go que você acabou de criar deve fazer com que o PowerShell produza o seguinte resultado:

      Output

      Hello, World!

      Neste passo, você usou um programa básico para verificar se seu espaço de trabalho em Go foi configurado corretamente.

      Conclusão

      Parabéns! Neste ponto, você tem um espaço de trabalho de programação em GO configurado em sua máquina local (com Windows) e pode começar um projeto de codificação!



      Source link

      Cómo instalar Go y configurar un entorno de programación local en macOS


      Introducción

      Go es un lenguaje de programación que se creó a partir de una frustración en Google. Continuamente, los desarrolladores tenían que elegir entre un lenguaje que se ejecutaba de forma eficiente, pero tardaba mucho en realizar compilaciones, y uno que ofrecía programación sencilla, pero se ejecutaba de forma ineficiente en la producción. Go se diseñó para tener las tres características disponibles al mismo tiempo: compilación rápida, facilidad de programación y ejecución eficiente en producción.

      Si bien Go es un lenguaje de programación versátil que puede utilizarse para muchos proyectos de programación distintos, es especialmente adecuado para los programas de redes o de sistemas distribuidos, y se ha ganado la reputación de “lenguaje de la nube”. Se centra en ayudar al programador moderno a ampliar sus capacidades con un conjunto sólido de herramientas, eliminar debates sobre el formato al incorporarlo en las especificaciones del lenguaje y permitir una implementación sencilla al realizar compilaciones en un único binario. Aprender a usar Go es sencillo, ya que cuenta con un conjunto de palabras claves muy reducido, por lo que es una excelente elección tanto para desarrolladores principiantes como experimentados.

      Este tutorial le servirá como guía para la instalación de Go en su máquina macOS local y la configuración de un espacio de trabajo de programación a través de la línea de comandos.

      Requisitos previos

      Necesitará un equipo con macOS que disponga de conexión a Internet y acceso administrativo.

      Paso 1: Abrir Terminal

      Completaremos la mayor parte de nuestra instalación y configuración en la línea de comandos, que es una alternativa para interactuar con la computadora sin gráficos. Es decir que, en lugar de hacer clic en botones, escribirá texto y recibirá retroalimentación de la computadora, también en texto. La línea de comandos, también conocida como shell, puede ayudar a modificar y automatizar muchas de las tareas que se realizan en un equipo a diario, y es una herramienta esencial para los desarrolladores de software.

      Terminal, de macOS, es una aplicación que puede usar para acceder a la interfaz de la línea de comandos. Al igual que cualquier otra aplicación, la puede encontrar accediendo a Finder, dirigiéndose a la carpeta Aplicaciones e ingresando en la carpeta Utilidades. Allí, haga doble clic en Terminal para abrirla como cualquier otra aplicación. De forma alternativa, puede usar Spotlight manteniendo presionadas la tecla CMD y la BARRA ESPACIADORA, y escribiendo “Terminal” en el cuadro que aparece para encontrarla.

      Terminal de macOS

      Hay muchos más comandos de Terminal que puede aprender para realizar tareas que tengan efectos más potentes. A través del artículo “Introducción al terminal de Linux“ puede orientarse mejor respecto del terminal de Linux, que es similar al de macOS.

      Ahora que abrió Terminal, puede descargar e instalar Xcode, un paquete de herramientas para desarrolladores que necesitará para instalar Go.

      Paso 2: Instalar Xcode

      Xcode es un entorno de desarrollo integrado (IDE) conformado por herramientas de desarrollo de software para macOS. Puede verificar si Xcode ya está instalado escribiendo lo siguiente en la ventana de Terminal:

      El siguiente resultado indica que Xcode está instalado:

      Output

      /Library/Developer/CommandLineTools

      Si aparece un error, instale Xcode desde App Store en su navegador web y acepte las opciones predeterminadas.

      Una vez que Xcode esté instalado, regrese a la ventana de Terminal. A continuación, deberá instalar la aplicación de herramientas de línea de comandos separada de Xcode, lo que podrá hacer escribiendo lo siguiente:

      En este punto, Xcode y su aplicación de herramientas de la línea de comandos están totalmente instalados, y estamos listos para instalar el administrador de paquetes Homebrew.

      Paso 3: Instalar y configurar Homebrew

      Si bien Terminal de macOS tiene mucho de la funcionalidad de los terminales de Linux y otros sistemas de Unix, no se entrega con un administrador de paquetes que admita prácticas recomendadas. Un administrador de paquetes es un conjunto de herramientas de software que automatizan los procesos de instalación, entre los que se incluyen la instalación inicial de software, su actualización y configuración, y su eliminación según sea necesario. Conservan las instalaciones en una ubicación central y pueden mantener todos los paquetes de software del sistema en formatos que se utilizan comúnmente. Homebrew proporciona un sistema de gestión de paquetes de software gratuito y de código abierto que simplifica la instalación de software en macOS.

      Para instalar Homebrew, escriba lo siguiente en la ventana de su terminal:

      • /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

      Homebrew está hecho con Ruby, por lo que modificará la ruta a Ruby de su computadora. El comando curl extrae un secuencia de comandos de la URL especificada. Esta secuencia de comandos proporcionará una explicación de lo que hará y luego pausará el proceso para solicitar su confirmación. Esto le proporciona mucha información sobre lo que la secuencia de comandos hará en el sistema y le da la oportunidad de verificar el proceso.

      Si debe ingresar su contraseña, tenga en cuenta que las pulsaciones de teclas no se mostrarán en la ventana de Terminal, pero sí se registrarán. Simplemente, pulse la tecla Intro una vez que ingrese la contraseña. Alternativamente, presione la letra y (“sí”) cuando se solicite para confirmar la instalación.

      Veamos los indicadores relacionados con el comando curl:

      • El indicador -f o --fail indica a la ventana de Terminal que no proporcione resultados de documentos HTML sobre errores del servidor.
      • El indicador -s o --silent silencia curl para que no muestre el medidor de progreso y, en combinación con el indicador -S o --show-error, controla que curl muestre un mensaje de error si falla.
      • El indicador -L o --location indica a curl que vuelva a realizar la solicitud a un nuevo lugar si el servidor indica que la página solicitada se movió a una ubicación distinta.

      Una vez que el proceso de instalación esté completo, dispondremos el directorio de Homebrew en la parte superior de la variable de entorno PATH. Esto garantizará que las instalaciones de Homebrew se realicen con herramientas que macOS pueda seleccionar automáticamente y que podrían entrar en conflicto con el entorno de desarrollo que crearemos.

      Debe crear o abrir el archivo ~/.bash_profile con el editor de texto de la línea de comandos *nano *usando el comando nano:

      Una vez que el archivo se abra en la ventana de Terminal, escriba lo siguiente:

      export PATH=/usr/local/bin:$PATH
      

      Para guardar sus cambios, mantenga presionadas las teclas CTRL y o, y luego pulse INTRO cuando se solicite. Ahora, puede cerrar nano manteniendo presionadas la tecla CTRL y la letra x.

      Active estos cambios ejecutando lo siguiente en Terminal:

      Una vez que lo haga, los cambios que realizó en la variable de entorno PATH surtirán efecto.

      Puede verificar que Homebrew se haya instalado correctamente escribiendo lo siguiente:

      Si no se requieren actualizaciones en este momento, el resultado de Terminal será el siguiente:

      Output

      Your system is ready to brew.

      También puede recibir una advertencia para ejecutar otro comando, como brew update, para garantizar que su instalación de Homebrew esté actualizada.

      Una vez que Homebrew esté listo, podrá instalar Go.

      Paso 1: Instalar Go

      Puede usar Homebrew para buscar todos los paquetes disponibles con el comando brew search. Para los fines de este tutorial, buscará paquetes o módulos relacionados con Go:

      Nota: Para este tutorial no se utiliza brew search go, dado que con este comando se muestran demasiados resultados. Debido a que go es una palabra muy pequeña y coincidiría con muchos paquetes, una opción que se ha vuelto común es la de usar golang como término de búsqueda. También se usa con frecuencia para buscar artículos relacionados con Go en Internet. El término Golang surgió del dominio de Go, golang.org.

      Terminal mostrará una lista de lo que puede instalar:

      Output

      golang golang-migrate

      Go será uno de los elementos de la lista. Proceda a instalarlo:

      En la ventana de Terminal encontrará información sobre el proceso de instalación de Go. Es posible que la instalación tarde unos minutos en completarse.

      Para verificar la versión de Go que instaló, escriba lo siguiente:

      Esto mostrará la versión específica de Go instalada, que por defecto será la más reciente y estable disponible.

      En el futuro, para actualizar Go, puede ejecutar los siguientes comandos a fin de actualizar Homebrew primero y luego Go. No es necesario hacerlo ahora, ya que acaba de instalar la versión más reciente:

      • brew update
      • brew upgrade golang

      El comando brew update actualizará las fórmulas para Homebrew, lo cual garantizará que cuente con la información más reciente de los paquetes que desee instalar. El comando brew update golang actualizará el paquete golang a la última versión del paquete.

      Es recomendable asegurarse de que la versión de Go esté actualizada.

      Una vez que instale Go en su computadora, estará listo para crear un espacio de trabajo para sus proyectos de Go.

      Paso 5: Crear su espacio de trabajo de Go

      Ahora que instaló Xcode, Homebrew y Go, podrá crear su espacio de trabajo de programación.

      El espacio de trabajo de Go contendrá dos directorios en su root:

      • src: directorio que contiene los archivos de origen de Go. Un archivo de origen es un archivo que se escribe con el lenguaje de programación Go. El compilador de Go utiliza los archivos de origen para crear un archivo binario ejecutable.
      • bin: directorio que contiene ejecutables compilados e instalados con las herramientas de Go. Los ejecutables son archivos binarios que se ejecutan en el sistema y realizan tareas. Normalmente, son programas compilados por su código fuente propio u otro código fuente de Go descargado.

      El subdirectorio src puede contener varios repositorios de control de versiones (como Git, Mercurial y Bazar). Verá directorios como github.com o golang.org cuando su programa importe bibliotecas de terceros. Si usa un repositorio de códigos como github.com, también dispondrá sus proyectos y archivos de origen en ese directorio. Esto permite una importación canónica de código en su proyecto. Las importaciones canónicas son las que hacen referencia a un paquete completo, como github.com/digitalocean/godo.

      Un espacio de trabajo típico puede tener el siguiente aspecto:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git reposistory metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      El directorio predeterminado para el espacio de trabajo de Go a partir de la versión 1.8 es su directorio principal de usuario con un subdirectorio go o $HOME/go. Si usa una versión de Go anterior a la 1.8, de todos modos se recomienda que utilice la ubicación $HOME/go para su espacio de trabajo.

      Emita el siguiente comando para crear la estructura de directorios para su espacio de trabajo de Go:

      • mkdir -p $HOME/go/{bin,src}

      La opción -p indica a mkdir que cree todos los parents en el directorio, incluso si todavía no existen. Con {bin,src}, se crea un conjunto de argumentos en mkdir y se indica a este que cree los directorios bin y src.

      Esto garantizará la creación de la siguiente estructura de directorios:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes de la versión 1.8 de Go, se debía establecer una variable de entorno local llamada $GOPATH. Si bien ya no es explícitamente necesario hacerlo, sigue siendo recomendable porque muchas herramientas de terceros aún dependen de que esta variable esté configurada.

      Puede configurar su $GOPATH al añadirlo a ~/.bash_profile.

      Primero, abra ~/.bash_profile con nano o con el editor de texto que elija:

      Configure su $GOPATH añadiendo lo siguiente al archivo:

      ~/.bash_profile

      export GOPATH=$HOME/go
      

      Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Para mayor comodidad, es común añadir el subdirectorio /bin del espacio de trabajo a su PATH en ~/.bash_profile:

      ~/.bash_profile

      export PATH=$PATH:$GOPATH/bin
      

      Ahora, debería contar con las siguientes entradas en su ~/.bash_profile:

      ~/.bash_profile

      export GOPATH=$HOME/go
      export PATH=$PATH:$GOPATH/bin
      

      Esto le permitirá ejecutar cualquier programa que realice compilaciones o descargas con las herramientas de Go en cualquier lugar de su sistema.

      Para actualizar su shell, emita el siguiente comando a fin de cargar las variables globales que acaba de crear:

      Puede verificar que $PATH esté actualizado al usando el comando echo e inspeccionando el resultado:

      Debería ver su $GOPATH/bin, que aparecerá en el directorio principal. Si iniciara sesión como sammy, vería /Users/sammy/go/bin en la ruta.

      Output

      /Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

      Ahora que creó el root del espacio de trabajo y estableció la variable de entorno $GOPATH establecida, creará sus futuros proyectos con la estructura de directorios siguiente. En este ejemplo, se supone que usa github.com como repositorio:

      $GOPATH/src/github.com/username/project
      

      Si trabajara en el proyecto https://github.com/digitalocean/godo, lo dispondría en el siguiente directorio:

      $GOPATH/src/github.com/digitalocean/godo
      

      Si estructura sus proyectos de esta manera, estarán disponibles con la herramienta go get. También facilitará la lectura más adelante.

      Puede verificar esto usando el comando go get para buscar la biblioteca godo:

      • go get github.com/digitalocean/godo

      Podemos ver que descargó correctamente el paquete godo haciendo un listado del directorio:

      • ls -l $GOPATH/src/github.com/digitalocean/godo

      Recibirá un resultado similar a este:

      Output

      -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

      A través de este paso, creó un espacio de trabajo de Go y configuró las variables de entorno necesarias. En el siguiente paso, probaremos el espacio de trabajo con código.

      Paso 6: Crear un programa simple

      Ahora que configuró su espacio de trabajo de Go, es hora de crear un programa “Hello, World!” simple. Esto garantizará que su espacio de trabajo funcione y le brindará la oportunidad de familiarizarse más con Go.

      Debido a que creará un único archivo de origen de Go, no un proyecto real, no es necesario que se encuentre en su espacio de trabajo para hacerlo.

      Desde el directorio principal, abra un editor de texto de línea de comandos, como nano y cree un archivo nuevo:

      Una vez que el archivo de texto se abra en Terminal, escriba su programa:

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

      Cierre nano con las teclas control y x, y cuando se le solicite guardar el archivo pulse y.

      Este código usará el paquete fmt e invocará la función Println con Hello, World! como argumento. Esto hará que se imprima la frase Hello, World! en el terminal cuando se ejecute el programa.

      Una vez que salga de nano y regrese a su shell, ejecute el programa:

      El programa hello.go que acaba de crear hará que el terminal genere el siguiente resultado:

      Output

      Hello, World!

      En este paso, utilizó un programa básico para verificar que su espacio de trabajo de Go se configure de forma correcta.

      Conclusión

      ¡Felicitaciones! En este punto, contará con un espacio de trabajo de programación de Go configurado en su máquina local con macOS y podrá iniciar un proyecto de codificación.



      Source link

      Cómo instalar Go y configurar un entorno de programación local en Ubuntu 18.04


      Introducción

      Go es un lenguaje de programación que se creó a partir de la frustración en Google. Continuamente, los desarrolladores tenían que elegir entre un lenguaje que se ejecutaba de forma eficiente, pero tardaba mucho en realizar compilaciones, y uno que ofrecía programación sencilla, pero se ejecutaba de forma ineficiente en la producción. Go se diseñó para tener las tres características disponibles al mismo tiempo: compilación rápida, facilidad de programación y ejecución eficiente en producción.

      Si bien Go es un lenguaje de programación versátil que puede utilizarse para muchos proyectos de programación distintos, es especialmente adecuado para los programas de redes o de sistemas distribuidos y se ha ganado la reputación de “lenguaje de la nube”. Se centra en ayudar al programador moderno a ampliar sus capacidades con un conjunto sólido de herramientas, eliminar debates sobre el formato al incorporarlo en las especificaciones del lenguaje y permitir una implementación sencilla al realizar compilaciones en un único binario. Aprender a usar Go es sencillo, ya que cuenta con un conjunto de palabras claves muy reducido, por lo que es una excelente elección tanto para desarrolladores principiantes como experimentados.

      Este tutorial le servirá como guía en la instalación y configuración de un espacio de trabajo de programación con Go a través de la línea de comandos. En él, se abarcará de forma explícita el procedimiento de instalación para Ubuntu 18.04, pero los principios generales pueden aplicarse a otras distribuciones de Debian Linux.

      Requisitos previos

      Necesitará una computadora o una máquina virtual con Ubuntu 18.04 instalado, acceso de administrador a esa máquina y conexión a Internet. Puede descargar este sistema operativo de la página de versiones de Ubuntu 18.04.

      Paso 1: Configurar Go

      En este paso, instalará Go tras descargar la versión actual de la página oficial de descargas de Go.

      Para hacerlo, deberá encontrar la URL del tarball para la versión binaria actual. También le convendrá tomar nota del hash SHA256 enumerado junto a ella, dado que lo usará para verificar el archivo descargado.

      Completará la mayor parte de la instalación y configuración en la línea de comandos, una alternativa para interactuar con la computadora sin gráficos. Es decir que, en lugar de hacer clic en botones, escribirá texto y recibirá retroalimentación de la computadora, también en texto.

      La línea de comandos, también conocida como shell o terminal, puede ayudar a modificar y automatizar muchas de las tareas que se realizan en una computadora a diario, y es una herramienta esencial para los desarrolladores de software. Hay muchos comandos del terminal que puede aprender para realizar tareas que tengan efectos más potentes. Para obtener más información sobre la línea de comandos, consulte el tutorial Introducción al terminal de Linux.

      En Ubuntu 18.04, puede encontrar la aplicación del terminal haciendo clic en el ícono de Ubuntu ubicado en la esquina superior izquierda de la pantalla y escribir terminal en la barra de búsqueda. Haga clic en el ícono de la aplicación del terminal para abrirla. Como alternativa, puede pulsar las teclas CTRL, ALT y T del teclado al mismo tiempo para abrir la aplicación del terminal de forma automática.

      Terminal de Ubuntu

      Una vez que el terminal esté abierto, instalará manualmente los binarios de Go. Si bien podría usar un gestor de paquetes, como apt-get, repasar los pasos de la instalación manual lo ayudará a comprender cualquier cambio de configuración que se requiera en su sistema para tener un espacio de trabajo válido de Go.

      Antes de descargar Go, asegúrese de encontrarse en el directorio principal (~):

      Utilice curl para obtener la URL del tarball que copió de la página oficial de descargas de Go:

      • curl -O https://dl.google.com/go/go1.12.1.linux-amd64.tar.gz

      Luego, utilice sha256sum para verificar el tarball:

      • sha256sum go1.12.1.linux-amd64.tar.gz

      El hash que se muestra al ejecutar el comando anterior debería coincidir con el de la página de descargas. Si no lo hace, no es un archivo válido, por lo que deberá volver a descargar el archivo.

      Output

      2a3fdabf665496a0db5f41ec6af7a9b15a49fbe71a85a50ca38b1f13a103aeec go1.12.1.linux-amd64.tar.gz

      A continuación, extraiga el archivo descargado e instálelo en la ubicación del sistema que desee. Se recomienda mantenerlo en /usr/local:

      • sudo tar -xvf go1.12.1.linux-amd64.tar.gz -C /usr/local

      Con esto, dispondrá de un directorio llamado go en el directorio /usr/local. A continuación, cambie de forma recursiva el propietario y el grupo de este directorio por root:

      • sudo chown -R root:root /usr/local/go

      Esto protegerá todos los archivos y garantizará que solo el usuario root pueda ejecutar los binarios de Go.

      Nota: Aunque /usr/local/go es la ubicación que se recomienda oficialmente, algunos usuarios pueden preferir o requerir diferentes rutas.

      Siguiendo este paso, descargó e instaló Go en su máquina con Ubuntu 18.04. A través del siguiente paso, configurará su espacio de trabajo de Go.

      Paso 2: Crear su espacio de trabajo de Go

      Ahora que Go está instalado, puede crear su espacio de trabajo de programación. El espacio de trabajo de Go contendrá dos directorios en su root:

      • src: directorio que contiene los archivos de origen de Go. Un archivo de origen es un archivo que se escribe con el lenguaje de programación Go. El compilador de Go utiliza los archivos de origen para crear un archivo binario ejecutable.
      • bin: directorio que contiene ejecutables creados e instalados con las herramientas de Go. Los ejecutables son archivos binarios que se ejecutan en su sistema y realizan tareas. Suelen ser programas compilados con su código fuente u otro código fuente de Go descargado.

      El subdirectorio src puede contener varios repositorios de control de versiones (como Git, Mercurial y Bazar). Esto permite una importación canónica de código en su proyecto. Las importaciones canónicas son las que hacen referencia a un paquete completo, como github.com/digitalocean/godo.

      Verá directorios como github.com, golang.org u otros cuando su programa importe bibliotecas de terceros. Si usa un repositorio de códigos como github.com, también dispondrá sus proyectos y archivos de origen en ese directorio. Analizaremos este concepto más adelante en este paso.

      Un espacio de trabajo típico puede tener el siguiente aspecto:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git repository metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      El directorio predeterminado para el espacio de trabajo de Go a partir de la versión 1.8 es su directorio principal de usuario con un subdirectorio go o $HOME/go. Si usa una versión de Go anterior a la 1.8, de todos modos, es recomendable utilizar la ubicación $HOME/go para su espacio de trabajo.

      Emita el siguiente comando para crear la estructura de directorios para su espacio de trabajo de Go:

      • mkdir -p $HOME/go/{bin,src}

      La opción -p indica a mkdir que cree todos los parents en el directorio, incluso si todavía no existen. Con {bin,src}, se crea un conjunto de argumentos en mkdir y se indica a este que cree los directorios bin y src.

      Esto garantizará la creación de la siguiente estructura de directorios:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes de la versión 1.8 de Go, se debía establecer una variable de entorno local llamada $GOPATH. $GOPATH le indicó al compilador dónde encontrar el código fuente de terceros importado, así como cualquier código fuente local que usted haya escrito. Si bien ya no se requiere explícitamente, sigue siendo recomendable hacerlo, ya que muchas herramientas de terceros aún dependen de que esta variable esté configurada.

      Puede configurar su $GOPATH añadiendo variables globales a su ~/.profile. Es recomendable añadir esto en el archivo .zshrc o .bashrc, según la configuración de su shell.

      Primero, abra ~/.profile con nano o el editor de texto de su elección:

      Establezca su $GOPATH agregando lo siguiente al archivo:

      ~/.profile

      export GOPATH=$HOME/go
      

      Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Para mayor comodidad, es común añadir el subdirectorio /bin del espacio de trabajo al PATH en ~/.profile:

      ~/.profile

      export PATH=$PATH:$GOPATH/bin
      

      Esto le permitirá ejecutar cualquier programa que realice compilaciones o descargas con las herramientas de Go en cualquier lugar de su sistema.

      Por último, deberá añadir el binario go a su PATH. Puede hacerlo agregando /usr/local/go/bin al final de la línea:

      ~/.profile

      export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin
      

      Al añadir /usr/local/go/bin a su $PATH, todas las herramientas de Go estarán disponibles en cualquier lugar de su sistema.

      Para actualizar su shell, emita el siguiente comando a fin de cargar las variables globales:

      Puede verificar que $PATH esté actualizado usando el comando echo e inspeccionando el resultado:

      Debería ver su $GOPATH/bin, que aparecerá en el directorio principal. Si inició sesión como root, verá /root/go/bin en la ruta.

      Output

      /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

      También verá la ruta a las herramientas de Go para /usr/local/go/bin:

      Output

      /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

      Verifique la instalación revisando la versión actual de Go:

      El resultado debería ser similar a este:

      Output

      go version go1.12.1 linux/amd64

      Ahora que creó el root del espacio de trabajo y estableció la variable de entorno $GOPATH, creará sus futuros proyectos con la estructura de directorios siguiente. En este ejemplo, se supone que usa github.com como repositorio:

      $GOPATH/src/github.com/username/project
      

      Por lo tanto, a modo de ejemplo, si estuviera trabajando en el proyecto https://github.com/digitalocean/godo, se almacenaría en el siguiente directorio:

      $GOPATH/src/github.com/digitalocean/godo
      

      Esta estructura de proyecto hará que los proyectos estén disponibles con la herramienta go get. También facilitará la lectura más adelante. Puede verificar esto usando el comando go get para buscar la biblioteca godo:

      • go get github.com/digitalocean/godo

      Esto descargará el contenido de la biblioteca godo y creará el directorio $GOPATH/src/github.com/digitalocean/godo en su máquina.

      Puede verificar si descargó correctamente el paquete godo haciendo un listado del directorio:

      • ll $GOPATH/src/github.com/digitalocean/godo

      El resultado deberá ser similar a este:

      Output

      drwxr-xr-x 4 root root 4096 Apr 5 00:43 ./ drwxr-xr-x 3 root root 4096 Apr 5 00:43 ../ drwxr-xr-x 8 root root 4096 Apr 5 00:43 .git/ -rwxr-xr-x 1 root root 8 Apr 5 00:43 .gitignore* -rw-r--r-- 1 root root 61 Apr 5 00:43 .travis.yml -rw-r--r-- 1 root root 2808 Apr 5 00:43 CHANGELOG.md -rw-r--r-- 1 root root 1851 Apr 5 00:43 CONTRIBUTING.md . . . -rw-r--r-- 1 root root 4893 Apr 5 00:43 vpcs.go -rw-r--r-- 1 root root 4091 Apr 5 00:43 vpcs_test.go

      A través de este paso, creó un espacio de trabajo de Go y configuró las variables de entorno necesarias. En el siguiente paso, probaremos el espacio de trabajo con código.

      Paso 3: Crear un programa simple

      Ahora que configuró el espacio de trabajo de Go, cree un programa “Hello, World! “. Esto asegurará que su espacio de trabajo funcione y le brindará la oportunidad de familiarizarse más con Go. Debido a que creará un único archivo de origen de Go, no un proyecto real, no es necesario que se encuentre en su espacio de trabajo para hacerlo.

      Desde el directorio principal, abra un editor de texto de línea de comandos, como nano y cree un archivo nuevo:

      Escriba su programa en el archivo nuevo:

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

      Este código usará el paquete fmt e invocará la función Println con Hello, World! como argumento. Esto hará que se imprima la frase Hello, World! en el terminal cuando se ejecute el programa.

      Cierre nano presionando las teclas CTRL y X. Cuando se le pregunte si desea guardar el archivo, presione Y y luego INTRO.

      Una vez que cierre nano y regrese a su shell, ejecute el programa:

      go run hello.go
      

      El programa hello.go hará que el terminal genere el siguiente resultado:

      Output

      Hello, World!

      Siguiendo este paso, utilizó un programa básico para verificar que su espacio de trabajo de Go se configure de forma correcta.

      Conclusión

      ¡Felicitaciones! En este punto, contará con un espacio de trabajo de programación de Go configurado en su máquina con Ubuntu y podrá iniciar un proyecto de codificación.



      Source link