Cómo crear archivos ejecutables GO en Ubuntu 17

Uno de los sistemas operativos más versátiles de Linux es sin lugar a dudas Ubuntu el cual gracias a sus prestaciones nos ofrece un entorno seguro y altamente configurable.

 

Además de esta gran ventaja, podemos encontrar numerosas herramientas y aplicaciones que permiten aumentar los niveles de rendimiento y productividad ofrecidos por Ubuntu y en base a esta posibilidad hoy analizaremos una herramienta que nos ofrece la posibilidad de crear archivos ejecutables de diversos sistemas operativos para posteriormente ser ejecutados con toda confianza, esta herramienta se denomina Go.

 

 

 

Antes de pasar a ver cómo crear el ejecutable daremos un breve repaso de cómo instalar Go en Ubuntu 17.

 

1. Cómo instalar y actualizar sistema Ubuntu 17

 

El primer paso a realizar es ejecutar los siguientes comandos para la actualización de los paquetes del sistema y su respectiva corrección de fallos:

sudo apt-get update
sudo apt-get -y upgrade

Una vez actualizado el sistema procedemos a descargar los binarios respectivos de Go ejecutando la siguiente línea:

wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz

 

 

Una vez descargado el archivo procedemos a su extracción ejecutando la siguiente línea:

sudo tar -xvf go1.7.4.linux-amd64.tar.gz

 

Moveremos el contenido a la ruta /usr/local:

sudo mv go /usr/local

2. Cómo ajustar el entorno de Go Ubuntu 17

 

Para que Go funcione de forma correcta será necesario que ingresemos las siguientes líneas asociadas a la ruta y acceso de Go:

export GOROOT=/usr/local/go
export GOPATH=$HOME/Solvetic/go
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

 

 

Es importante tener en cuenta que la ruta GOPATH es donde se alojaran los archivos de creación.
Una vez realizado esto podremos ejecutar los siguientes comandos para verificar la versión y entorno de Go:

go versión
go env

 

Con esto ya hemos instalado Go y podremos proceder a la creación de los ejecutables.
Hay que reseñar que actualmente la versión 1.8 de Go está en fase beta, pero si deseamos instalarla podremos ejecutar los siguientes comandos:

sudo add-apt-repository ppa:longsleep/golang-backports
 sudo apt-get update 
sudo apt-get install golang-go

3. Cómo descargar el código fuente en Ubuntu 17

Este es el paso inicial antes de crear cualquier ejecutable con Go, obtener su código fuente el cual obtenemos usando el parámetro go get.

 

El proceso incluye la clonación de los paquetes en la ruta GOPATH/src/ y posteriormente si aplica estos se construirán en la ruta GOPATH/bin.

 

La sintaxis a usar para la descarga del código fuente es:

go get (ruta del paquete)

La ruta por lo general la encontramos en la base de Github. También agregaremos el parámetro -u el cual instala todas las dependencias o la actualización de estas.

 

Para este caso usaremos Caddy el cual es un servidor web escrito en Go y ejecutaremos la siguiente línea para su descarga:

go get -u github.com/mholt/caddy/caddy

 

Como vemos no se despliega ningún resultado visible pero todo el contenido será almacenado en la ruta

GOPATH/src/github.com/mholt/caddy.

Si deseamos comprobarlo podremos ejecutar la línea which caddy. En algunos casos pueden generarse errores asociados a Git, para ello ejecutaremos lo siguiente para su corrección:

sudo apt install git

4. Cómo construir el ejecutable en Ubuntu 17

 

Una vez descargado Caddy y para ello ejecutaremos la siguiente línea:

go build github.com/mholt/caddy/caddy

Este comando tampoco nos desplegará ningún resultado visible. Si deseamos especificar una ruta en especial podremos agregar el parámetro -o de la siguiente forma. Podremos cambiar la ruta build/caddy-server por la deseada. Este comando creara el archivo ejecutable y de paso, si no existe, el directorio ./build.

go build -o build/caddy-server github.com/mholt/caddy/caddy

5. Cómo instalar el ejecutable en Ubuntu 17

La instalación de un ejecutable consiste en crear el archivo .exe y almacenarlo en la ruta GOPATH/bin. Para este proceso usaremos el comando go install el cual creara el ejecutable en el lugar correcto.

 

Ejecutaremos lo siguiente. Al ejecutar el comando tampoco será visible algún resultado para el usuario pero el archivo habrá sido creado en la ruta GOPATH/bin.

go install github.com/mholt/caddy/caddy

6. construir ejecutables para diversos sistemas en Ubuntu 17

En este punto veremos el poder de Go y como se convierte en un valioso aliado gracias a las múltiples posibilidades de creación de ejecutables.

 

La sintaxis a implementar será la siguiente. El comando env es el encargado de crear un entorno modificado para el uso de las respectivas variables.

env GOOS=OS Objetivo GOARCH=Arquitectura go build Ruta del paquete

La siguiente es unan tabla con todas las opciones que nos ofrece Go:

 

 

En este caso crearemos un ejecutable de Windows con una arquitectura amd de 64 bits, ejecutaremos lo siguiente:

env GOOS=windows GOARCH=amd64 go build github.com/mholt/caddy/caddy

 

Como es costumbre en Go no veremos ningún resultado visible pero internamente se ha realizado el proceso.

 

Esto creará el archivo .exe en base al sistema elegido y para comprobarlo ejecutaremos la siguiente línea:

ls caddy.exe

 

 

7. Cómo crear el script para la compilación multiplataforma en Ubuntu 17

 

Con este objetivo crearemos un script llamado go-executable-build.bash el cual será un script que se encarga de realizar todas las acciones de compilación de forma práctica y podrá ser usado a nivel general con total compatibilidad.

 

Para ello usaremos la línea cd ~ y ejecutaremos lo siguiente:

nano go-executable-build.bash

Allí debemos ingresar la siguiente información:

#!/usr/bin/env bash

package=$1
if [[ -z "$package" ]]; then
  echo "usage: $0 <package-name>"
  exit 1
fi
package_split=(${package//\// })
package_name=${package_split[-1]}

platforms=("windows/amd64" "windows/386" "darwin/amd64")

for platform in "${platforms[@]}"
do
    platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}
    output_name=$package_name'-'$GOOS'-'$GOARCH
    if [ $GOOS = "windows" ]; then
	    output_name+='.exe'
    fi  

    env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package
    if [ $? -ne 0 ]; then
	    echo 'An error has occurred! Aborting the script execution...'
	    exit 1
    fi
done

Este será el script y su función es la siguiente:

#!/usr/bin/env bash: Esta línea indica que interprete analizara el script.

package=$1: Esta línea tomara el primer argumento de la línea de comandos y lo almacenará en su variable.
 if [[ -z "$package" ]]; then
  echo "usage: $0 <package-name>"
  exit 1
fi

Estas líneas se encargan de desplegar un mensaje en caso de que el valor no haya sido ingresado.
El parámetro if analiza el valor de la variable package.

package_split=(${package//\// }): Esta línea divide la ruta de importación del paquete en una matriz usando el delimitador /.
package_name=${package_split[-1]}: Esta línea toma el nombre de la matriz.
platforms=("windows/amd64" "windows/386" "darwin/amd64"): Allí ingresaremos el sistema operativo y arquitectura a crear.
for platform in "${platforms[@]}"
do
platform_split=(${platform//\// })
    GOOS=${platform_split[0]}
    GOARCH=${platform_split[1]}

Done

Estas líneas dividen los valores de la plataforma en las variables GOOS y GOARCH.

output_name=$package_name'-'$GOOS'-'$GOARCH

    if [ $GOOS = "windows" ]; then
	    output_name+='.exe'
    fi

Con esta secuencia crearemos el nombre del ejecutable y cuando se trata de sistemas operativos Windows debemos agregar la extensión .exe.

env GOOS=$GOOS GOARCH=$GOARCH go build -o $output_name $package: Esta línea nos permite crear el archivo ejecutable.
if [ $? -ne 0 ]; then
	    echo 'An error has occurred! Aborting the script execution...'
	    exit 1

Con estas líneas será desplegado un mensaje de error en caso de que la construcción del ejecutable sea errónea.

 

 

 

Una vez ingresemos esta información guardamos los cambios usando la combinación de teclas

 

 

Ctrl + O

 

 

y salimos del editor usando

 

Ctrl + X

 

 

Asignaremos los permisos para que el script sea ejecutable usando la siguiente línea:

chmod +x go-executable-build.bash

El último paso será probar la configuración del script ejecutando lo siguiente. Como vemos no ha sido generado ningún error.

./go-executable-build.bash github.com/mholt/caddy/caddy

 

 

8. Cómo comprobar los archivos ejecutables en Ubuntu 17

Para comprobar que contamos con los ejecutables correctos en Go basta con ejecutar la siguiente línea:

ls caddy*

 

Allí veremos los ejecutables tanto de 32 como de 64 bits para el sistema seleccionado, en este caso Windows. Si deseamos usar otras plataformas basta con acceder al script y realizar los cambios en la línea platforms.

 

Hemos visto como Go es una aplicación fundamental cuando se requiere contar con múltiples ejecutables facilitando la gestión y distribución de estos en la organización.