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.

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] (https://www.digitalocean.com/community/tutorials/an-introduction-to-the-linux-terminal)" 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:

xcode-select -p

El siguiente resultado indica que Xcode está instalado:

Output
/Library/Developer/CommandLineTools

Si aparece un error, instale [Xcode desde App Store] (https://itunes.apple.com/us/app/xcode/id497799835?mt=12&ign-mpt=uo%3D2) 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:

xcode-select --install

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:

nano ~/.bash_profile

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:

source ~/.bash_profile

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:

brew doctor

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:

brew search golang

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:

brew install golang

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:

go version

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:

nano ~/.bash_profile

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

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:

export PATH=$PATH:$GOPATH/bin

Ahora, debería contar con las siguientes entradas en su ~/.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:

. ~/.bash_profile

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

echo $PATH

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:

nano hello.go

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:

go run hello.go

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.