Cómo instalar Go y configurar un entorno de programación en Windows 10

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 para la instalación de Go en su máquina con Windows 10 local y la configuración de un entorno de programación mediante la línea de comandos.

Requisitos previos

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

Paso 1: Abrir y configurar PowerShell

Completará la mayor parte de la instalación y configuración en la interfaz de 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.

PowerShell es un programa de Microsoft que proporciona una interfaz shell de línea de comandos. Las tareas administrativas se realizan ejecutando cmdlets, que se pronuncia command-lets: clases especializadas del marco de software .NET que puede realizar operaciones. PowerShell se ofrece en código abierto desde agosto del 2016 y ahora está disponible para diferentes plataformas para sistemas Windows y UNIX (incluyendo Mac y Linux).

Para hallar PowerShell de Windows, puede hacer clic con el botón secundario del mouse sobre el ícono del menú de inicio, en la esquina inferior izquierda de la pantalla. Cuando aparezca el menú, haga clic en Buscar y luego escriba PowerShell en la barra de búsqueda. Cuando aparezcan las opciones, haga clic sobre Windows PowerShell desde la aplicación de escritorio. Para este tutorial seleccione, Ejecutar como administrador. Cuando aparezca un cuadro de diálogo que contenga la pregunta ¿Desea permitir que esta aplicación realice cambios en el equipo?, haga clic en Sí.

Una vez que haga esto, verá una interfaz basada en texto que tiene una cadena de palabras que tiene este aspecto:

Salga de la carpeta del sistema escribiendo el siguiente comando:

cd ~

Luego, se posicionará en un directorio de inicio como PS C:\Users\sammy.

Para continuar con el proceso de instalación, primero debe establecer permisos a través de PowerShell. Está configurado para ejecutarse en el modo más seguro de forma predeterminada y e existen varios niveles de permisos que puede establecer como administrador.

• Restricted es la política de ejecución predeterminada. En este modo, no podrá ejecutar secuencias de comandos y PowerShell funcionará solo como un shell interactivo.
• AllSigned le permitirá ejecutar todas las secuencias de comandos y archivos de configuración que estén firmados por un editor de confianza, lo cual significa que podría exponer su máquina al riesgo de ejecutar secuencias de comandos maliciosas que estén firmadas por un editor de confianza.
• RemoteSigned le permitirá ejecutar secuencias de comandos y archivos de configuración que se descarguen de Internet y estén firmados por editores de confianza, con lo cual su equipo quedará de nuevo expuesto a vulnerabilidades si estas secuencias de comandos de confianza son en realidad maliciosas.
• Unrestricted ejecutará las secuencias de comandos y los archivos de configuración descargados de Internet tan pronto como confirme que comprende que el archivo se descargó de Internet. En este caso, no se requiere firma digital, de modo que podría dejar su equipo expuesto al riesgo de ejecutar secuencias de comandos no firmadas y potencialmente maliciosas descargadas de Internet.

A través de este tutorial, usará la política de ejecución RemoteSigned para establecer los permisos para el usuario actual. Esto permitirá que PowerShell acepte secuencias de comandos de confianza sin hacer que los permisos sean tan amplios como en el caso de la categoría Unrestricted. Introduzca lo siguiente en PowerShell:

Set-ExecutionPolicy -Scope CurrentUser

PowerShell le pedirá que proporcione una política de ejecución. Introduzca lo siguiente para usar RemoteSigned:

RemoteSigned

Una vez que pulse ENTER, se le solicitará confirmar el cambio en la política de ejecución. Escriba la letra y para permitir que se apliquen los cambios. Puede confirmar que esto funcionó pidiendo los permisos actuales en la computadora:

Get-ExecutionPolicy -List

Debería ver un resultado que tenga este aspecto:

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

Esto confirma que el usuario actual puede ejecutar las secuencias de comandos de confianza descargadas de Internet. Ahora, podrá descargar los archivos que necesitaremos para configurar nuestro entorno de programación de Go.

Paso 2: Instalar el administrador de paquetes Chocolatey

Un administrador de paquetes es un conjunto de herramientas de software cuyo propósito es automatizar los procesos de instalación. Esto incluye la instalación inicial, la actualización, la configuración y la desinstalación del software según sea necesario. Conservan las instalaciones de software en una ubicación central y pueden mantener todos los paquetes de software del sistema en formatos que se utilizan comúnmente.

Chocolatey es un administrador de paquetes de línea de comandos creado para Windows que funciona como apt-get en Linux. Chocolatey se encuentra disponible como versión de código abierto y le permitirá instalar rápidamente aplicaciones y herramientas. Lo utilizará para descargar lo que necesita para su entorno de desarrollo.

Antes de instalar la secuencia de comandos, léala para confirmar que está de acuerdo con los cambios que realizará en su equipo. Para hacer esto, utilice el marco de secuencias de comandos NET para descargar y mostrar la secuencia de comandos Chocolatey en la ventana del terminal.

Comience creando un objeto WebClient llamado $script que comparta los ajustes de conexión de Internet con Internet Explorer:

$script = New-Object Net.WebClient

Eche un vistazo a las opciones disponibles enlazando el objeto $script con | a la clase Get-Member:

$script | Get-Member

Con esto, se mostrarán todos los miembros (propiedades y métodos) de este objeto WebClient:

 . . .
[secondary_label 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…
 . . .

Mirando el resultado, puede identificar el método DownloadString usado para mostrar la secuencia de comandos y la firma en la ventana PowerShell. Utilice este método para inspeccionar la secuencia de comandos:

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

Tras inspeccionar la secuencia de comandos, instale Chocolatey escribiendo lo siguiente en PowerShell:

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

El cmdlet iwr, o Invoke-WebRequest, le permite extraer datos de la web. Esto pasará la secuencia de comandos a iex, o el cmdlet Invoke-Expression, que ejecutará los contenidos de la secuencia de comandos y ejecutará la instalación para el administrador de paquetes Chocolatey.

Permita que PowerShell instale Chocolatey. Una vez que se complete la instalación, puede comenzar a instalar herramientas adicionales con el comando choco.

Si necesita actualizar Chocolatey en cualquier momento en el futuro, ejecute el siguiente comando:

choco upgrade chocolatey

Una vez que instale el administrador de paquetes, podrá realizar las demás instalaciones que necesite para el entorno de programación de Go.

Paso 3: Instalar el editor de texto Nano (opcional)

En este paso, instalará nano, un editor de texto que utiliza una interfaz de línea de comandos. Puede usar nano para escribir programas directamente en PowerShell. Éste no es un paso obligatorio, ya que puede usar un editor de texto con interfaz de usuario gráfica, como Notepad. En este tutorial se recomienda usar nano, pues le servirá para acostumbrarse a usar PowerShell.

Utilice Chocolatey para instalar nano:

choco install -y nano

El indicador -y confirma automáticamente que desea ejecutar la secuencia de comandos sin que se le pida confirmación.

Una vez que nano esté instalado, podrá usar el comando nano para crear nuevos archivos de texto. Lo utilizará posteriormente en este tutorial para escribir su primer programa Go.

Paso 1: Instalar Go

Como hizo con nano en el paso anterior, usará Chocolatey para instalar Go:

choco install -y golang

PowerShell ahora instalará Go y generará un resultado en PowerShell durante ese proceso. Una vez completada la instalación, debería ver el siguiente 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:\ProgramData\chocolatey\logs\chocolatey.log).

Después de la instalación, confirmará que Go está instalado. Para ver los cambios, cierre y vuelva a abrir PowerShell como administrador, y luego compruebe la versión de Go disponible en su equipo local:

go version

Recibirá un resultado similar al siguiente:

Output
go version go1.12.1 windows/amd643.7.0

Una vez instalado Go, podrá configurar un espacio de trabajo para sus proyectos de desarrollo.

Paso 5: Crear su espacio de trabajo de Go

Ahora que instaló Chocolatey, nano 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 creados 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 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, se recomienda utilizar la ubicación $HOME/go para su espacio de trabajo.

Ejecute el siguiente comando para acceder al directorio $HOME:

cd $HOME

A continuación, cree la estructura de directorios para su espacio de trabajo de Go:

mkdir go/bin, go/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.

Debido a que usó Chocolatey para la instalación, esta variable de entorno deberá estar configurada. Puede verificar esto con el siguiente comando:

$env:GOPATH

Debería ver el siguiente resultado, con su nombre de usuario en lugar de sammy:

Output
C:\Users\sammy\go

Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Por conveniencia, es común añadir el subdirectorio bin del espacio de trabajo a su $PATH. Puede hacer esto usando el comando setx en PowerShell:

setx PATH "$($env: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.

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

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

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

Recibirá un resultado similar a este:

Output
    Directory: C:\Users\sammy\go\src\github.com\digitalocean\godo


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

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ó el espacio de trabajo de Go, cree un programa “Hello, World!” simple. Mundo!”. Esto garantizará que su espacio de trabajo se configure correctamente 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:

nano hello.go

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

package main

import "fmt"

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

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

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

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

go run hello.go

El programa hello.go que acaba de crear debería hacer que PowerShell 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 equipo local con Windows y podrá iniciar un proyecto de creación de código.