Tutorial

Cómo crear e instalar programas de Go

Go

Introducción

Hasta ahora, en nuestra serie Cómo escribir código en Go utilizó el comando go run para compilar automáticamente su código fuente y hacer funcionar el ejecutable resultante. Aunque este comando es útil para probar su código en la línea de comandos, para distribuir o implementar su aplicación es necesario que compile su código en un ejecutable binario intercambiable o en un archivo único que contenga código de bytes de máquina que pueda ejecutar su aplicación. Para hacer esto, puede usar la cadena de herramientas de Go para compilar e instalar su programa.

En Go, el proceso de traducir el código fuerte a un binario ejecutable se denomina compilación. Una vez compilado, este ejecutable contendrá no solo su aplicación, sino también todo el código de soporte necesario para ejecutar el binario en la plataforma de destino. Esto significa que un binario de Go no necesita dependencias del sistema como las herramientas de Go para ejecutarse en un nuevo sistema, a diferencia de otros lenguajes como Ruby, Python o Node.js. Poner estos ejecutables en una ruta de archivo ejecutable en su propio sistema le permitirá ejecutar el programa desde cualquier parte de su sistema. Esto es instalar el programa en su sistema.

A través de este tutorial, usará las herramientas de Go para ejecutar, compilar e instalar un programa Hello, World! de ejemplo que le permitirá usar, distribuir, e implementar futuras aplicaciones de manera efectiva.

Requisitos previos

Para seguir el ejemplo de este artículo, necesitará lo siguiente:

Configurar y ejecutar el binario de Go

Primero, cree una aplicación que se usará como ejemplo para mostrar la cadena de herramientas de Go. Para hacer esto, usará el programa clásico “Hello, World!” del tutorial Cómo escribir su primer programa en Go.

Cree un directorio llamado greeter en su directorio src:

  • mkdir greeter

A continuación, posiciónese en el directorio recién creado y cree el archivo main.go en el editor de texto que prefiera:

  • cd greeter
  • nano main.go

Una vez abierto el archivo, añada el siguiente contenido:

src/greeter/main.go
package main

import "fmt"

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

Cuando se ejecute, este programa imprimirá la frase Hello World! en la consola y luego se cerrará correctamente.

Guarde el archivo y ciérrelo.

Para probar el programa, utilice el comando go run como en los tutoriales anteriores:

  • go run main.go

Obtendrá el siguiente resultado:

Output
Hello, World!

Como se mencionó antes, el comando go run compiló su archivo de origen en un binario ejecutable y luego ejecutó el programa compilado. Sin embargo, el propósito de este tutorial es compilar el binario de tal forma que pueda compartirlo y distribuirlo como desee. Para hacer esto, usará el comando go build en el siguiente paso.

Compilar binarios de Go con go build

Usando go build, puede generar un binario ejecutable para nuestra aplicación de Go de ejemplo, lo que le permitirá distribuir e implementar el programa donde lo desee.

Pruebe esto con main.go. En su directorio greeter, ejecute el siguiente comando:

  • go build

Si no proporciona un argumento para este comando, go build compilará automáticamente el programa main.go en su directorio actual. El comando incluirá todos sus archivos *.go en el directorio. También creará todo el código de soporte necesario para poder ejecutar el binario en computadoras que tengan la misma arquitectura de sistema, independientemente de que este tenga los archivos de origen .go o incluso una instalación de Go.

En este caso, compiló su aplicación greeter en un archivo ejecutable que se añadió a su directorio actual. Compruebe esto ejecutando el comando ls:

  • ls

Si usa macOS o Linux, encontrará un nuevo archivo ejecutable al que se asignó el nombre del directorio en el cual compiló su programa:

Output
greeter main.go

Nota: En Windows, su ejecutable será greeter.exe.

Por defecto, go build generará un ejecutable para la plataforma y arquitectura actuales. Por ejemplo, si se crea en un sistema linux/386, el ejecutable será compatible con cualquier otro sistema linux/386, incluso si Go no está instalado. Go admite la compilación para otras plataformas y arquitecturas. Puede obtener más información sobre esto en nuestro artículo Crear aplicaciones de Go para diferentes sistemas operativos y arquitecturas.

Ahora que creó su ejecutable, inícielo para asegurarse de que el binario se haya creado correctamente. En macOS o Linux, ejecute el siguiente comando:

  • ./greeter

En Windows, ejecute esto:

  • greeter.exe

El resultado del binario coincidirá con el resultado cuando ejecute el programa con go run:

Output
Hello, World!

Con esto, habrá creado un único binario ejecutable que contendrá no solo su programa, sino también todo el código del sistema necesario para ejecutar ese binario. Ahora, podrá distribuir este programa a nuevos sistemas o implementarlo a un servidor, sabiendo que el archivo siempre ejecutará el mismo programa.

En la siguiente sección de este tutorial, se explicará la manera de asignar un nombre a un binario y de cambiarlo, para que pueda controlar mejor el proceso de compilación de su programa.

Cambiar el nombre del binario

Ahora que conoce la manera de generar un ejecutable, el siguiente paso es identificar la forma en que Go selecciona un nombre para el binario y personalizar el nombre para su proyecto.

Cuando ejecuta go build, el valor predeterminado supone que Go decida automáticamente el nombre del ejecutable generado. Hace esto de una de las siguientes formas: si está usando Go Modules, Go utilizará la última parte del nombre de su módulo; de lo contrario, empleará el nombre del directorio actual. Éste es el método usado en la última sección, cuando creó el directorio greeter, se posicionó en él y ejecutó go build.

Veremos en más detalle el método de módulos. Si dispusiera de un archivo go.mod en su proyecto con una declaración module como la siguiente:

go.mod
module github.com/sammy/shark

El nombre predeterminado para el ejecutable generado sería shark.

En programas más complejos que requieren convenciones de nomenclatura específicas, estos valores predeterminados no siempre serán la mejor opción para asignar un nombre a su binario. En estos casos, sería mejor personalizar su resultado con el indicador -o.

Para probar esto, cambie el nombre del ejecutable que creó en la última sección por hello y sitúelo en una subcarpeta llamada bin. No tiene que crear esta carpeta; Go hará esto por su cuenta durante el proceso de compilación.

Ejecute el siguiente comando go build con el indicador -o:

  • go build -o bin/hello

El indicador -0 hace que Go haga coincidir el resultado del comando con el argumento que elija. En este caso, el resultado es un nuevo ejecutable llamado hello en una subcarpeta llamada bin.

Para probar el nuevo ejecutable, posiciónese en el nuevo directorio y ejecute el binario:

  • cd bin
  • ./hello

Recibirá el siguiente resultado:

Output
Hello, World!

Ahora, podrá personalizar el nombre de su ejecutable para que se adapte a las necesidades de su proyecto y completar nuestro estudio sobre cómo compilar binarios en Go. Con go build, sin embargo, aún experimentará limitaciones para ejecutar su binario desde el directorio actual. Para usar los ejecutables recién creados desde cualquier parte de su sistema, puede instalarlo usando go install.

Instalar programas Go con go install

Hasta ahora, en el artículo analizamos la forma de generar binarios ejecutables desde nuestros archivos de origen .go. Estos ejecutables son útiles para la distribución, la implementación y la prueba, pero aún no se pueden ejecutar desde fuera de sus directorios de origen. Esto sería un problema si quisiera usar su programa de forma activa, como si hubiera desarrollado una herramienta de línea de comandos para asistir a flujo de trabajo en su propio sistema. Para que los programas se puedan usar de forma más sencilla, puede instalarlos en su sistema y acceder a ellos desde cualquier parte.

Para comprender lo que esto significa, usará el comando go install a fin de instalar su aplicación de ejemplo.

El comando go install tiene un comportamiento casi idéntico al de go build, pero en vez de dejar el ejecutable en el directorio actual, o en un directorio especificado por el indicador -o, dispone el ejecutable en el directorio $GOPATH/bin.

Para encontrar el punto en el que está su directorio $GOPATH, ejecute el siguiente comando:

  • go env GOPATH

El resultado que reciba variará, pero el predeterminado es el directorio go situado dentro de su directorio $HOME:

Output
$HOME/go

Ya que go install dispondrá los ejecutables generados en un subdirectorio de $GOPATH llamado bin, este directorio debe añadirse a la variable de entorno $PATH. Esto se abarca en el paso *Crear su espacio de trabajo de Go *del artículo Cómo instalar Go y configurar un entorno de programación local de los requisitos previos.

Una vez configurado el directorio $GOPATH/bin, posiciónese en su directorio greeter:

  • cd ..

Ahora ejecute el comando install:

  • go install

Con esto, se compilará su binario y se dispondrá en $GOPATH/bin. Para probar esto, ejecute lo siguiente:

  • ls $GOPATH/bin

Con esto se listará el contenido de $GOPATH/bin:

Output
greeter

Nota: El comando go install no admite el indicador -0, por lo cual usará uno de los nombres predeterminados descritos anteriormente para nombrar el ejecutable.

Una vez instalado el binario, compruebe si el programa se ejecuta desde fuera de su directorio de origen. Regrese a su directorio de inicio:

  • cd $HOME

Utilice lo siguiente para ejecutar el programa:

  • greeter

Obtendrá el siguiente resultado:

Output
Hello, World!

Ahora podrá instalar en su sistema los programas que escriba, lo que le permitirá usarlos desde cualquier sitio y en cualquier momento en que los necesite.

Conclusión

A través de este tutorial, pudo comprobar que las herramientas de Go facilitan la compilación de binarios ejecutables a partir de código fuente. Estos binarios pueden distribuirse para funcionar en otros sistemas, incluso en aquellos que no tienen herramientas ni entornos de Go. También utilizó go install para crear e instalar automáticamente nuestros programas como ejecutables en el $PATH del sistema. Con go build y go install, podrá compartir y usar su aplicación como lo desee.

Ahora que conoce los aspectos básicos de go build, puede ver la forma de crear código fuente modular en el tutorial Personalizar binarios de Go con etiquetas de compilación, o de realizar compilaciones para diferentes plataformas a través de Compilar aplicaciones de Go para diferentes sistemas operativos y arquitecturas. Si desea obtener más información acerca del lenguaje de programación Go en general, consulte toda la serie Cómo realizar codificaciones en Go.

Creative Commons License