Cómo instalar Go y configurar un entorno de desarrollo local en Windows 10

Introducción

Go es un lenguaje de programación que surgió de la frustración en Google. Los desarrolladores se veían constantemente obligados a elegir entre un lenguaje que se ejecutaba eficientemente, pero tardaba mucho en compilarse, o un lenguaje fácil de programar, pero ineficiente en producción. Go fue diseñado para tener las tres cosas a la vez: 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 usarse en diversos proyectos, es especialmente adecuado para aplicaciones de red/sistemas distribuidos y se le conoce como el "lenguaje de la nube". Se centra en ayudar al programador moderno a lograr más con un conjunto robusto de herramientas, elimina las discusiones sobre formato al incluirlo en la especificación del lenguaje y simplifica la implementación al compilarlo en un solo binario. Go es fácil de aprender, con un conjunto muy reducido de palabras clave, lo que lo convierte en una excelente opción tanto para principiantes como para desarrolladores experimentados.

Este tutorial lo guiará a través de la instalación de Go en su máquina local con Windows 10 y la configuración de un entorno de programación a través de la línea de comandos.

Requisitos previos

• Necesita un dispositivo Windows 10 con acceso administrativo que esté conectado a Internet.

Paso 1: Abrir y configurar PowerShell

Completará la mayor parte de la instalación y configuración mediante una interfaz de línea de comandos, que es una forma no gráfica de interactuar con su computadora. Es decir, en lugar de hacer clic en botones, escribe texto y recibe información de su computadora en forma de texto. La línea de comandos, también conocida como shell, puede ayudarle a modificar y automatizar muchas de las tareas que realiza a diario en su computadora y es una herramienta esencial para los desarrolladores de software.

PowerShell es un programa de Microsoft que proporciona una interfaz de línea de comandos. Las tareas administrativas se realizan mediante la ejecución de cmdlets (comandos pronunciados), que son clases especializadas del marco de software .NET que pueden realizar operaciones. PowerShell, de código abierto desde agosto de 2016, ya está disponible en todas las plataformas, tanto para Windows como para sistemas tipo Unix (incluidos Mac y Linux).

Para encontrar Windows PowerShell, haga clic con el botón derecho en el icono del menú Inicio, en la esquina inferior izquierda de la pantalla. Cuando aparezca el menú, haga clic en Buscar y escriba PowerShell en la barra de búsqueda. Cuando se le presenten las opciones, haga clic con el botón derecho en Windows PowerShell desde la aplicación de Escritorio. Para este tutorial, seleccione Ejecutar como administrador. Cuando aparezca un cuadro de diálogo que le pregunte si desea permitir que este programa realice cambios en su PC, haga clic en Sí.

Una vez que hagas esto, verás una interfaz basada en texto que tiene una cadena de palabras como esta:

Salga de la carpeta del sistema escribiendo el siguiente comando:

cd ~

Entonces estarás en un directorio raíz como PS C:\Users\sammy.

Para continuar con el proceso de instalación, primero debe configurar los permisos mediante PowerShell. De forma predeterminada, está configurado para ejecutarse en el modo más seguro. Existen varios niveles de permisos que puede configurar como administrador:

• La política de ejecución predeterminada es Restringida. En este modo, no se pueden ejecutar scripts y PowerShell solo funciona como un shell interactivo.
• AllSigned le permite ejecutar todos los scripts y archivos de configuración que estén firmados por un editor confiable, lo que significa que potencialmente puede exponer su dispositivo al riesgo de ejecutar scripts maliciosos que estén firmados por un editor confiable.
• RemoteSigned le permite ejecutar scripts y archivos de configuración descargados de Internet firmados por editores confiables, lo que nuevamente expone su dispositivo a vulnerabilidades si estos scripts confiables son realmente maliciosos.
• En cuanto detecte que el archivo se descargó de Internet, Unrestricted ejecutará todos los scripts y archivos de configuración descargados. En este caso, no se requiere firma digital, por lo que puede exponer su dispositivo al riesgo de ejecutar scripts sin firmar y potencialmente maliciosos descargados de Internet.

En este tutorial, usará la política de ejecución RemoteSigned para establecer permisos para el usuario actual. Esto permite que PowerShell acepte scripts de confianza sin imponer tantos permisos como con una licencia sin restricciones. Introduzca lo siguiente en PowerShell:

Set-ExecutionPolicy -Scope CurrentUser

PowerShell le solicitará una política de ejecución. Para usar RemoteSigned, introduzca lo siguiente:

RemoteSigned

Tras pulsar INTRO, se le pedirá que confirme el cambio en la política de ejecución. Escriba "y" para aplicar los cambios. Puede verificarlo solicitando los permisos actuales del dispositivo:

Get-ExecutionPolicy -List

Debería obtener un resultado parecido a esto:

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

Esto verifica que el usuario actual pueda ejecutar scripts confiables descargados de internet. Ahora puede descargar los archivos necesarios para configurar el entorno de desarrollo de Go.

Paso 2: Instalar el administrador de paquetes Chocolatey

El Administrador de Paquetes es un conjunto de herramientas de software que automatizan los procesos de instalación. Esto incluye la instalación inicial, la actualización y configuración del software, y la eliminación de software cuando sea necesario. Mantienen las instalaciones de software en una ubicación central y pueden mantener todos los paquetes de software del sistema en formatos de uso común.

Chocolatey es un gestor de paquetes de línea de comandos diseñado para Windows que funciona como apt-get en Linux. Disponible en código abierto, Chocolatey te ayuda a instalar rápidamente programas y herramientas. Lo usarás para descargar lo que necesites para tu entorno de desarrollo.

Antes de instalar el script, léalo para confirmar que está satisfecho con los cambios que realizará en su equipo. Para ello, use el framework de scripting .NET para descargar y mostrar el script de Chocolatey en una ventana de terminal.

Comience creando un objeto WebClient llamado $script que comparta la configuración de conexión a Internet con Internet Explorer:

$script = New-Object Net.WebClient

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

$script | Get-Member

Esto devolverá 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…
. . .

Al observar la salida, puede identificar el método DownloadString utilizado para mostrar el script y la firma en la ventana de PowerShell. Utilice este método para inspeccionar el script:

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

Después de revisar el script, instale Chocolatey escribiendo lo siguiente en PowerShell:

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

El cmdlet iwr o Invoke-WebRequest permite extraer datos de la web. Pasa el script al cmdlet iex o Invoke-Expression, que ejecuta el contenido del script y realiza la instalación para la gestión de paquetes de Chocolatey.

Deje que PowerShell instale Chocolatey. Una vez completada la instalación, puede empezar 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

Al instalar el administrador de paquetes, puede instalar el resto de las cosas que necesita para el entorno de programación Go.

Paso 3 – Instalar Nano Text Editor (opcional)

En este paso, instalará nano, un editor de texto con interfaz de línea de comandos. Puede usar nano para escribir programas directamente en PowerShell. Este paso no es obligatorio, ya que también puede usar un editor de texto con interfaz gráfica de usuario, como el Bloc de notas. Este tutorial recomienda usar nano para familiarizarse con PowerShell.

Utilice Chocolatey para instalar Nano:

choco install -y nano

La bandera -y confirma automáticamente que desea ejecutar el script sin pedir confirmación.

Una vez instalado nano, puedes usar el comando nano para crear nuevos archivos de texto. Más adelante en este tutorial, lo usarás para escribir tu primer programa en Go.

Paso 4 – Instalar Go

Al igual que hiciste con nano en el paso anterior, usarás Chocolatey para instalar Go:

choco install -y golang

Nota: Dado que "go" es una palabra muy corta, se ha vuelto común usar "golang" para referirse a la instalación de paquetes y al buscar artículos relacionados con Go en internet. El término "Golang" surgió del dominio Go, que es golang.org.

PowerShell instalará Go y generará la salida en PowerShell durante el proceso. Una vez completada la instalación, debería ver la siguiente salida:

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).

Una vez finalizada la instalación, confirme que Go está instalado. Para ver los cambios, cierre y vuelva a abrir PowerShell como administrador y, a continuación, compruebe la versión de Go en su equipo local:

go version

Obtendrá un resultado similar al siguiente:

Output
go version go1.12.1 windows/amd643.7.0

Después de instalar Go, puede configurar un espacio de trabajo para sus proyectos de desarrollo.

Paso 5: Crea tu espacio de trabajo de Go

Ahora que tienes Chocolatey, nano y Go instalados, puedes crear tu espacio de trabajo de programación.

El espacio de trabajo de Go contendrá dos directorios en su raíz:

• src: El directorio que contiene los archivos fuente de Go. Un archivo fuente es un archivo que se escribe con el lenguaje de programación Go. El compilador de Go utiliza los archivos fuente para crear un archivo binario ejecutable.
• bin: Un directorio que contiene archivos ejecutables generados e instalados por la herramienta Go. Los archivos ejecutables son archivos binarios que se ejecutan en el sistema y realizan tareas. Suelen ser programas compilados a partir del código fuente del usuario o de otro código fuente de Go descargado.

El subdirectorio src puede contener varios repositorios de control de versiones (como Git, Mercurial y Bazaar). Cuando tu aplicación importe bibliotecas de terceros, verás directorios como github.com o golang.org. Si usas un repositorio de código como github.com, también colocarás tus proyectos y archivos fuente en ese directorio. Esto te permite importar código canónicamente a tu proyecto. Una importación canónica apunta a un paquete completo, como github.com/digitalocean/godo.

Así es como podría lucir un espacio de trabajo típico:

.
├── 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 el directorio de inicio de usuario con un subdirectorio llamado go o $HOME/go. Si utiliza una versión de Go anterior a la 1.8, se recomienda usar la ubicación $HOME/go para su espacio de trabajo.

Emita el siguiente comando para ir al directorio $HOME:

cd $HOME

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

mkdir go/bin, go/src

Esto garantiza que actualmente exista la siguiente estructura de directorio:

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

Antes de Go 1.8, era necesario configurar una variable de entorno local llamada $GOPATH. Aunque esto ya no es necesario, se considera una buena práctica, ya que muchas herramientas de terceros aún dependen de la configuración de esta variable.

Dado que usaste Chocolatey para la instalación, esta variable de entorno ya debería estar configurada. Puedes verificarlo con el siguiente comando:

$env:GOPATH

Deberías ver el siguiente resultado con tu nombre de usuario en lugar de sammy:

Output
C:\Users\sammy\go

Cuando Go compila e instala las herramientas, las coloca en la carpeta $GOPATH/bin. Para mayor comodidad, es habitual agregar el subdirectorio bin del espacio de trabajo a $PATH. Puede hacerlo con el comando setx en PowerShell:

setx PATH "$($env:path);$GOPATH\bin"

Ahora le permite ejecutar cualquier programa que compile o descargue a través de la herramienta Go en cualquier parte de su sistema.

Ahora que ha creado la raíz de su espacio de trabajo y configurado la variable de entorno $GOPATH, creará sus proyectos futuros con la siguiente estructura de directorios. Este ejemplo asume que utiliza github.com como repositorio:

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

Si estuvieras trabajando en el proyecto https://github.com/digitalocean/godo, lo enumerarías como:

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

Estructurar tus proyectos de esta manera los hará accesibles con la herramienta Go Get. También mejorará su legibilidad más adelante.

Puedes verificar esto usando el comando go get para obtener la biblioteca godo:

go get github.com/digitalocean/godo

Nota: Si no tiene Git instalado, Windows abrirá un cuadro de diálogo preguntándole si desea instalarlo. Haga clic en Sí para continuar y siga las instrucciones de instalación.

Al listar el directorio, puedes ver que el paquete godo se ha descargado exitosamente:

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

Obtendrás 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

En este punto, ha creado un espacio de trabajo de Go y ha configurado las variables de entorno necesarias. A continuación, probará el espacio de trabajo con código.

Paso 6 – Crea una aplicación sencilla

Ahora que tienes tu espacio de trabajo de Go configurado, crea un programa sencillo de "¡Hola, mundo!". Esto garantizará que tu espacio de trabajo esté configurado correctamente y te permitirá familiarizarte mejor con Go. Dado que estás creando un archivo fuente de Go y no un proyecto real, no necesitas estar en tu espacio de trabajo para hacerlo.

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

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!")
}

Salga de nano presionando CTRL y X. Cuando se le solicite guardar el archivo, presione Y y luego ENTER.

Este código usa el paquete fmt y llama a la función Println con "¡Hola, mundo!" como argumento. Esto hace que la frase "¡Hola, mundo!" se imprima en la terminal al ejecutar el programa.

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

go run hello.go

El programa hello.go que creó debería hacer que PowerShell produzca el siguiente resultado:

Output
Hello, World!

En este paso, utilizó una aplicación básica para verificar que su espacio de trabajo de Go esté configurado correctamente.

Resultado

¡Felicitaciones! Ya has configurado un espacio de trabajo de programación Go en tu equipo Windows y puedes empezar un proyecto de programación.