5

GoPath, Workspace e Importar paquetes externos en GO

Una de las primeras cosas que como desarrolladores debemos tener en cuenta es como cada lenguaje establece convenciones y buenas practicas especificas para su desarrollo. Basado en esto he querido de la forma mas sencilla posible compartir lo que he estado aprendiendo sobre este tema.

Lo primero que debemos saber es que si bien podríamos tener la libertad de poner nuestro código de Go en cualquier lugar lo recomendable es organizar el código de una manera especifica.

Por convención todo tu código y el código que importes debes estar almacenado en un solo Workspace . Un workspace no es mas que un directorio dentro de tu sistema de archivos cuya ruta debe ser almacenada dentro de la variable de entorno GOPATH.

Para configurar GOPATH en bash shells linux, agregue la siguiente línea al archivo ~/.bash_profile:
export GOPATH=$HOME/go

El workspace go va a contener dos directorios:

  • src contiene los archivos fuente de Go.

  • bin contiene comandos ejecutables.

La herramienta go crea e instala binarios en el directorio bin.

El subdirectorio src generalmente contiene múltiples repositorios de control de versiones (como Git o Mercurial) que rastrean el desarrollo de uno o más paquetes fuente.

A partir de la configuración de nuestro workspace vamos a seguir la siguiente ruta para nuestros proyectos:

$GOPATH/src/github.com/user/project

Si bien es una estructura diferente a como venimos acostumbrados, esta tiene sus ventajas, te la explico un poco:

  • github.com: Lo primero que vemos es que luego del directorio src/ nos encontramos un directorio llamado github.com/ esto es porque un workspace en go puede contener múltiples repositorios administrados por github, asi mismo cada repositorio puede depender de otros repositorios.

  • user: hace mencion en principio a tu username en github, sustituye user por tu username, dentro de este directorio van a estar almacenados tus proyectos/repositorios. y esta es una de las cosas mas utilies de esta estructura de directorios pues en go vamos a poder hacer la importancion de paquetes de terceros a los cuales vamos a hacer referencia a traves de su repositorio, cada vez que importemos un nuevo paquete externo desde github, este sera descargado por el comando go get y almacenado en src/github.com/ convirtiendose este directorio en una especie de node_modules o vendors en otros proyectos, con la diferencia de que en go los paquetes externos no se almacenan dentro del proyecto sino que estaran disponibles para otro proyectos tambien.

  • project: en realidad proyecto no es mas que el directorio de cada uno de tus proyectos y que iran dentro de tu tu directorio /github.com/user/

Con esta estructura ya podras crear proyectos profesionales e importar paquetes de terceros.

Para importacion de paquetes vamos a utilizar el comando go get de la siguiente manera:

$ got get https://github.com/valyala/fasthttp

Este comando descargara dentro del directorio github.com/ el paquete fasthtttp del user valyala.

Fasthtttp es un paquete para crear un servidor web de alto rendimiento que puede llegar a ser hasta 10x mas rapido que el paquente nativo net/http.

Para hacer uso de este package primero que nada hacemos la importacion:

`package main

import (
“fmt”
“log”
github.com/buaazp/fasthttprouter
github.com/valyala/fasthttp
)`

Nota que estoy importando tambien el paquete fasthttprouter, este paquete nos ayudara a gestiornar rutas con mejor rendimiento.
Para finalizar en el siguiente codigo vamos a levantar un servidor http haciendo uso de los paquetes externos que acabamos de importar.

`func main() {

router := fasthttprouter.New()
router.GET("/", welcome)
log.Fatal(fasthttp.ListenAndServe(":3000", router.Handler))

}

func welcome(ctx *fasthttp.RequestCtx) {
fmt.Fprint(ctx, “Welcome!\n”)
}`

De esta forma podremos ejecutar este codigo con go run main.go y tendresmos corriendo nuestro server.

En conclusion llevando a cabo estos pasos tendremos:

  • Un workspace configurado dentro de GOPATH/src/github.com/myuser

  • Habremos creado un nuevo proyecto que podriamos llamar server y estara ubicado en GOPATH/src/github.com/myuser/server

  • Importaremos dos paquetes externos que van a estar almacenados dentro de GOPATH/src/github.com/ por lo que ya no tendremos solo el directorio de nuestro username, adicionalmente tendremos un directorio nuevo por cada paquete importado.

  • Gracias a esta estructura de directorios los paquetes externos importados podran reutilizarse en otros proyectos sin volverlos a descargar.

Escribe tu comentario
+ 2
Ordenar por:
2
11336Puntos

Disculpen que hay porciones de código que no están correctamente definidos, por alguna razón el editor fallo en esos casos y no tuve como editar la publicación.

1
2369Puntos

Muy buen tutoria! Y gran oportunidad para detallar más el tema del workspace de Go, que no se profundizó tanto en el curso.

1

Hola David! Muchas gracias por crear éste tutorial, es bastante útil. Te queria hacer algunas preguntas:
Al setear nuestro GOPATH, ¿los directorios src y bin se crean solos o hay que hacerlo manualmente?
Cuando te refieres al directorio “github.com”, ¿significa que tenemos que crear una carpeta dentro de src? ¿Lo mismo para “user” y “project”?

1
11336Puntos
2 años

Hola Martin que bueno que te sirva. Tendrías que crear el directorio src/ los otros directorios como bin y pkg se crean automáticamente a la misma altura de src. Dentro de src/ también tendrías que tu mismo crear el directorio github.com/ y luego dentro el directorio con el nombre de tu github username.

2
2369Puntos
2 años

Algo que puede ser confuso al principio es eso mismo, que incluso cuando instalas Go no se crea ninguna estructura de carpetas en automático (como uno podría pensar). Como menciona @davidvalecillo, tú mismo tienes que crear la estructura de carpetas de lo que tú vas a usar; es decir, el código de tus proyectos. Si seguiste el curso probablemente instalaste VS Code y la extensión de Go. La extensión de Go de VS Code instala algunas herramientas para funcionar mejor y éstas se instalan en /src, /pkg y /bin. Esto da la impresión de que se generan en automático (esto me pasó la primera vez que instalé Go junto a VS Code 😂). De cualquier forma, instalar la extensión ayudan a que tú mismo no tengas que generar la estructura y la extensión lo hace por ti 😃

go-workspace

$HOME/go
├ pkg
├ bin
└ src
		└ github.com
				└ avelinoschz
						└ myproject