Espacios de trabajo, construcción, compilación cruzada y ejecución en Linux

En este artículo, vamos a explicar cómo construir, compilar, hacer compilación cruzada, ejecutar archivos binarios Go y crear espacios de trabajo. Estos temas son muy importantes si considera desarrollar y implementar aplicaciones Go a gran escala en un entorno de producción.

En primer lugar, debemos explicar qué es un espacio de trabajo y por qué lo necesita.

Espacios de trabajo

El espacio de trabajo es un directorio que consiste de la siguiente jerarquía:

Bin

El directorio bin significa binario que incluye los archivos binarios del proyecto que se ha creado.

Pkg

El directorio pkg significa paquetes que incluyen todos los paquetes externos que pertenecen al proyecto.

Src

El src define el directorio de fuente que incluye los códigos fuente y su dependencia.

Al instalar Go en Linux, su entorno predeterminado se encuentra en /usr, donde se encuentra todos los archivos / paquetes predeterminados necesarios. Ahora la pregunta es: ¿por qué crear un espacio de trabajo? Crear un espacio de trabajo es importante y si desea crear su propio proyecto personalizado que incluya solamente los paquetes necesarios que pertenecen a su proyecto. En todo nuestro ejemplo anterior, estábamos usando el entorno predeterminado (conocido como GOROOT) para ejecutar nuestros códigos Go. Un espacio de trabajo le brinda la capacidad de importar paquetes y códigos en su propio espacio de trabajo. Una vez que se crea su espacio de trabajo, todos los paquetes que importó para su proyecto se almacenarán en el directorio pkg de su espacio de trabajo.

Antes de que pueda comenzar a usar su espacio de trabajo, debe configurar GOPATH para que apunte al directorio de su proyecto.

Cuando especifica la variable de entorno GOPATH, Go suponga que exista un ejecutable Go en el directorio especificado. Además, GOPATH le dice a Go dónde está su espacio de trabajo para importar paquetes, instalar binarios y almacenar archivos intermedios.

En Linux, las variables de entorno Go están en el archivo .bashrc. Las siguientes instrucciones demuestran cómo configurar su directorio para el espacio de trabajo y GOPATH en las variables de entorno.

Comience creando el directorio del proyecto. En este ejemplo, vamos a crear esta carpeta en nuestro escritorio.

Después de crear el directorio, debe crear la carpeta src donde encuentra los códigos fuente.

El archivo Go principal tiene que ser guardado en la carpeta src , ya que para crear su espacio de trabajo la carpeta src necesita por lo menos un archivo .go que contiene la paquete principal. Para este ejemplo, utilizaremos Atom como nuestro editor de código, pero todo depende de su preferencia personal. Para obtener más información sobre los editores de código que se pueden utilizar, lea este artículo.

Crear un nuevo archivo en blanco

Escriba los siguientes códigos Go

package main

func main(){

}

Guarde el archivo en la carpeta src

Ahora viene la parte interesante, especifica su GOPATH para crear el espacio de trabajo. Antes de que podamos continuar con este paso, debe obtener la ruta absoluta del directorio. Para obtener esta ruta, simplemente haga clic derecho en el directorio del proyecto y seleccione Propiedades en la pestaña Básico.

Esta ruta será tu GOPATH. Ahora para configurar el GOPATH, inicie la terminal y ingrese el comando ls -la para conseguir la lista de todos los directorios (incluidos los archivos / directorios ocultos).

Presione la tecla Enter y aparecerá la lista de archivos / directorios y vea si el archivo .bashrc aparece en la lista de resultados. En Linux, el GOPATH debe ser configurado en el archivo .bashrc.

Abra el archivo .bashrc ejecutando el siguiente comando:

nano .bashrc

Una vez que .bashrc está abierto, debe agregar la ruta absoluta del directorio de su proyecto como su variable GOPATH y GOBIN. Agregue las siguientes líneas en el archivo .bashrc :

export GOPATH=$HOME/Escritorio/go_project

export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

export GOBIN=$GOPATH/bin

Para guardar sus cambios de .bashrc, presione ctrl + x, presione ‘y‘ y presione intro.

Guarde su nueva configuración y cierre la terminal por completo para que los cambios surtan efecto.

Para verificar si los cambios surtieron efecto, ejecute el siguiente comando:

go env

Desde el resultado del entorno Go, compruebe si GOBIN y GOPATH están configurados.

Si todo está configurado correctamente, solo queda el último paso que es crear su espacio de trabajo. Para completar este último paso, simplemente abra la terminal, navegue a la carpeta src del directorio del proyecto donde se encuentra el archivo .go.

cd ‘/home/[usario]/Escritorio/go_project/src’

y ejecute el siguiente comando:

go install

Cuando ejecuta este comando, los ejecutables se compilarán y almacenado en bin.

Felicitaciones, su espacio de trabajo está creado y ahora puede comenzar a importar paquetes a su proyecto utilizando el comando go get. Por ejemplo, ejecute el siguiente comando:

go get -u github.com/gorilla/mux

y la carpeta pkg aparece con su paquete en su entorno.

Cuando ejecuta este comando Go recorrerá la base de código y obtendrá los paquetes externos a los que se hace referencia. En este caso, ve la referencia externa, obtiene el paquete y lo pone a disposición en el espacio de trabajo actual.

Importar paquetes

La mayoría de los paquetes serán importado desde otros repositorios a través del sistema de control de versiones como Git, Mercurial, SVN o Bazaar. Cuando importa un paquete, Go recupera la base de código de Git y comprueba la última confirmación de la rama predeterminada.

Go build

Para compilar la aplicación Go, debe usar el comando go build y el archivo ejecutable será generado. Cuando un ejecutable es creado, significa que este archivo ejecutable no requiere ninguna biblioteca externa para ejecutarse.

Antes de construir un ejecutable, Go pasa por un conjunto de reglas estrictas para evitar errores en su código. Este comando también le ayuda a que su código sea más fácil de leer. Una cosa que siempre debe recordar es que el compilador Go está aquí para ayudarte y no para hacerle la vida imposible. El propósito del compilador es compilar y aumentar la calidad de su código Go.

Una de las reglas de Go es que no puedes incluir cualquier paquete innecesario.

package main
import (
«fmt»
«os»
)

func main() {
fmt.Println(«Hello world!»)
}

Esto generará el siguiente mensaje de error cuando intente construir este archivo Go:

# command-line-arguments
./main.go:5:1: imported and not used: «os»

Aunque puede romper esta regla con el uso de un guión bajo que omite esta restricción.

package main
import (
«fmt»
_»os»
)

func main() {
fmt.Println(«Hello world!»)
}

El compilador verifica estrictamente el uso de punto y coma porque Go requiere el uso de punto y coma como terminadores en muchos contextos. El compilador inserta automáticamente los puntos y comas necesarios cuando cree que es necesario. Mira el siguiente ejemplo:

package main
import (
«fmt»
)

func main()
{
fmt.Println(«Hello world!»)
}

Aunque esto código parece correcto, si intenta ejecutarlo, consiga un mensaje de error de sintaxis, y el código no se compilará y, por lo tanto, no se ejecutará:

# command-line-arguments
./main.go:7:6: missing function body
./main.go:8:1: syntax error: unexpected semicolon or newline before {

Esto se porque se pone las llaves de apertura {en su propia línea hará que el compilador Go inserte un punto y coma al final de main(). Esto producirá el mensaje de error.

Go format (fmt)

El comando go fmt establece su código en el formato correcto. Lo que significa que si su código parece desordenado, puede iniciar este comando para formatear su código.

Compilación cruzada

Compilación cruzada es importante si desea generar un ejecutable para ejecutarlo en una otra máquina con diferente arquitectura. Afortunadamente, Go tiene soporte incorporado para la compilación cruzada, lo que significa que solo necesita una sola máquina para su desarrollo.

Para realizar una compilación cruzada de un archivo Go, debe configurar GOOS (sistema operativo de destino) y GOARCH (arquitectura de destino). Para recuperar esta información, ejecute el siguiente comando:

  • go version
  • go version go1.13.4 linux/amd64

En este ejemplo, el GOOS es linux y amd64 el GOARCH. La compilación cruzada se puede realizar con el siguiente comando:

env GOOS=[ sistema operativo] GOARCH=[ arquitectura] go build [archive go]

En este ejemplo, el comando será como lo siguiente:

env GOOS=linux GOARCH=arm64 go build main.go

El resultado consiste en el siguiente ejemplo:

Este comando genera un archivo binario que funciona en linux que usan la arquitectura ARM. Consulte este pagina para la lista de GOOS y GOARCH disponibles.

Ejecutar códigos Go

El comando go run se ha utilizado en mayoría de nuestros ejemplos en artículos anteriores. Al ejecutar el comando go run, el compilador Go crea un archivo ejecutable temporal. Durante y después de la ejecución de la aplicación Go, no verá este archivo ejecutable temporal. Es que la aplicación se ejecuta automáticamente, este ejecutable temporal se creará y eliminará una vez que el programa haya terminado de ejecutar. Esto significa que Go no deja ningún archivo en su disco duro.

Para crear un archivo ejecutable, debe usar el comando go build. Este comando crea este ejecutable independiente que se puede ejecutar directamente sin necesidad de usar el comando go run. El comando go build consiste del siguiente orden:

go build [nombre del archivo go]

En este ejemplo donde el nombre del archivo Go es main.go, la ejecución será la siguiente:

go build main.go

Una vez que se completa la ejecución, el archivo ejecutable main sera creado en su directorio src. Para ejecutar este archivo ejecutable, primero navegue al directorio src en su espacio de trabajo y ingrese el siguiente comando:

./main

Síguenos:

Deja una respuesta

Tu dirección de correo electrónico no será publicada.