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

PostedFebruary 7, 2020 642 views GoDevelopmentUbuntu 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 (~):

  • cd ~

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:

  • nano ~/.profile

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:

  • . ~/.profile

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

  • echo $PATH

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:

  • go version

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:

  • nano hello.go

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.

0 Comments

Creative Commons License