¿Cómo configuro la variable de entorno GOPATH en Ubuntu? ¿Qué archivo debo editar?

Estoy tratando de hacer un go get:

go get github.com/go-sql-driver/mysql

y falla con el siguiente error:

package github.com/go-sql-driver/mysql: cannot download, $GOPATH not set. For more details see: go help gopath

cuando hago un go env, una lista de valores de Go se muestra a continuación:

ubuntu@ip-xxx-x-xx-x:~$ go env
GOARCH="amd64"
GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH=""
GORACE=""
GOROOT="/usr/lib/go"
GOTOOLDIR="/usr/lib/go/pkg/tool/linux_amd64"
CC="gcc"
GOGCCFLAGS="-g -O2 -fPIC -m64 -pthread"
CGO_ENABLED="1"

claramente el GOPATH no está configurado, ¿cómo y dónde lo configuro?

Veo muchos hilos que mencionan este error, pero ninguno que responda a mi pregunta, ¿qué archivo debe editarse para proporcionar un valor para esta ruta?

Nueva manera:

Mira esta respuesta.

Vieja forma:

Simplemente agregue las siguientes líneas a ~ / .bashrc y esto persistirá. Sin embargo, puede usar otras rutas que desee como GOPATH en lugar de $ HOME / go en mi muestra.

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

Ubuntu 14.04

export GOPATH=$HOME/go

Además, puede agregar esta cadena al archivo

$HOME/.bashrc

GOPATH debe establecerse en un directorio vacío recién creado. Este es el "espacio de trabajo", donde descarga paquetes, etc. Yo uso ~ / .go.

Por ejemplo:

mkdir ~/.go
echo "GOPATH=$HOME/.go" >> ~/.bashrc
echo "export GOPATH" >> ~/.bashrc
echo "PATH=\$PATH:\$GOPATH/bin # Add GOPATH/bin to PATH for scripting" >> ~/.bashrc
source ~/.bashrc

fuente: http : //www.larry-ichelin/blog/2013/12/15/setting-up-a-go-environment-in-ubuntu-12-dot-04/

Nueva forma: módulos Go

Desde Go 1.11, ya no tiene que usar GOPATH. Simplemente vaya al directorio de su proyecto y haga esto una vez:

go mod init github.com/youruser/yourrepo

• Con esto, Go crea una raíz de módulo en ese directorio.
• Puede crear tantos módulos como desee.
• Para obtener instrucciones paso a paso, también vea esta respuesta .

Old Way: GOPATH

Si insiste en trabajar con GOPATH, preste atención a esto:

• Desde Go 1.8, no necesita configurar su GOPATH o GOROOT.
• GOPATH por defecto está bajo su directorio de usuario / home.

De la documentación :

Si no se establece GOPATH, se supone que es $ HOME / go en sistemas Unix y% USERPROFILE% \ go en Windows. Si desea utilizar una ubicación personalizada como su espacio de trabajo, puede establecer la variable de entorno GOPATH.

Si, por ejemplo, es un Ubuntu, después de instalar los paquetes:

$sudo apt install golang -y

Simplemente agregue las siguientes líneas a ~ / .bashrc (De su usuario)

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

export GOPATH=/path/desired/here

No es necesario editar ningún archivo, solo podemos usar el comando anterior para editar directamente las variables de entorno Go.

Escribe este código en la Terminal.

export GOPATH=path/to/your/gopath/directory

Nota : Esto se restablecerá en cada nueva ventana de Terminal o reinicio del sistema.

Para ser persistente, pegue el siguiente código en su archivo .zshrco de .bashrcacuerdo con su shell. Esos archivos en su directorio de inicio . Será como a continuación.

export PATH=path/to/some/other/place/composer/for/example
export GOPATH=path/to/your/gopath/directory
export PATH=$PATH:$GOPATH/bin

Necesitarás GOPATH más tarde también. Así que agrégalo a ~/.bashrc.

Si ha configurado algo que necesita modificación de las variables de entorno, por ejemplo, Java, Go, etc., será muy familiar.

Asumiré que tiene la siguiente estructura de directorios en algún lugar como su ruta Go:

\---[folder name]
    +---bin
    +---pkg
    \---src

• abrir una nueva terminal
• tipo sudo nano /etc/environment
• encontrar PATH=...e ir al final del mismo y añadir una coma :después de la última ruta luego pegar en su plena go pathpor ejemplo,/home/user/gocode

y listo, esto debería hacerlo persistente a través del sistema.

Esto es lo que me funcionó en Ubuntu 15.10 usando fish shell:

# ~/.config/fish/config.fish

set -g -x PATH /usr/local/bin $PATH
set -g -x GOPATH /usr/share/go

Luego tuve que cambiar los permisos en la gocarpeta (se configuró en root)

sudo chown <name>:<name> -R /usr/share/go

go path podría estar donde quiera, solo cree un directorio y configure la variable de ruta global en el nombre de GOPATH en su entorno.

mkdir ~/go
export GOPATH=~/go
go get github.com/go-sql-driver/mysql

Con Go 1.8 (Q2 2017), no tendrá que editar ningún archivo si acepta el GOPATHvalor predeterminado (configurado para usted)

$HOME/go

Puede ver los comentarios sobre el número 17262 y el voto de Twitter asociado :

Al elegir un valor predeterminado GOPATH, podemos facilitar nuestra documentación porque podemos decir cosas como

$ go get github.com/foo/bar

revisará el github.com/foo/barrepositorio en $HOME/go/src/github.com/foo/bar.

No necesitamos distraer a los recién llegados con la necesidad de establecer una variable ambiental, todo lo que tenemos que hacer es poner una pequeña nota entre paréntesis en la parte inferior de la página

$HOME/goes la ruta predeterminada a su espacio de trabajo.
Si desea cambiar esta ruta, establezca la GOPATHvariable en algo de su elección.

Mi entorno de ir se parecía al tuyo.

$go env
GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH=""
GORACE=""
GOROOT="/usr/lib/go-1.6"
GOTOOLDIR="/usr/lib/go-1.6/pkg/tool/linux_amd64"
GO15VENDOREXPERIMENT="1"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"

Lo resolví configurando GOPATH en / usr / lib / go . Pruébalo.

export GOPATH=/usr/lib/go
export PATH=$PATH:$GOPATH/bin

GOPATH es una variable de entorno para su ubicación en el espacio de trabajo. GOROOT es una variable de entorno para su directorio de instalación. Aunque GOROOT y GOPATH se configuran automáticamente (si no hubiera un error) durante el tiempo de instalación, para especificarlo manualmente puede seguir el siguiente proceso. Además, para obtener más información, puede consultar la página wiki de GO .

Es mejor configurar GOPATH en un directorio dentro de su directorio de inicio, por ejemplo, $ HOME / go,% USERPROFILE% \ go (Windows).

1. Esta es una solución mac, que se prueba en macOS Sierra, ver. 10.12, y también en Gogland-EAP, que ha sido introducido como IDE para la programación Go por JetBrains.

En su tipo de terminal

vim ~/.profile

en el documento abierto en la Terminal, presione i y agregue la siguiente ruta

GOPATH=/path/to/a/directory/inside/home/directory
GOROOT=/path/to/you/go/library
PATH=$PATH:$GOPATH:$GOROOT:$GOROOT/bin

presione ESC y escriba : x . Por último, debe reiniciar ( cerrar y abrir ) su terminal o Cerrar sesión y volver a iniciar sesión .

2. Para la configuración de Windows y Linux, consulte la página wiki de Go en Githab en Configuración de GOPATH-Golang .

PRECAUCIÓN No establezca GOROOT y GOPATH en el mismo directorio, de lo contrario recibirá una advertencia.

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

Y es posible que desee comprobar por $ go env

(Ubuntu)

Si no establece un GOPATH, se usará el predeterminado.

Debe agregar $ GOPATH / bin a su PATH para ejecutar cualquier binario instalado en $ GOPATH / bin, o debe escribir $ GOPATH / bin / the-command. Agregue esto a su ~ / .bash_profile

export PATH=$GOPATH/bin:$PATH

Comando GOPATH actual:

go env GOPATH

Cambiar el comando GOPATH:

export GOPATH=$HOME/your-desired-path

Esta ha sido la cosa más molesta con la que lidiar. Con la esperanza de ahorrarle tiempo.

IF go se instaló como usuario root. El usuario raíz del archivo de texto bash_profile de su sistema ~ / .bash_profile necesita tener $ GOROOT asignado al directorio go install y $ GOPATH debe asignarse al directorio go / src.

  ...$# sudo su
  ...$# vi ~/.bash_profile

    ***Story continues in vi editor***

    GOROOT=$GOROOT:/usr/local/go
    GOPATH=$GOPATH:/usr/local/go/src
    ...
    [your regular PATH stuff here]
    ...

asegúrese de que el camino a seguir binario esté en su ruta en .bash_profile

RUTA = $ RUTA: $ INICIO / bin: / usr / local / bin: / usr / local / go / bin

Esta RUTA puede ser tan larga como una cadena debe ser ... para agregar nuevos elementos separados por dos puntos:

salir del editor vi y guardar el perfil de bash (: wq significa escribir y salir)

  [esc] 
  [shift] + [:] 
  :wq

Debe cerrar sesión en la terminal e iniciar sesión nuevamente para que el perfil se inicie nuevamente ... o simplemente puede iniciarlo usando exportar.

...$# export GOPATH=/usr/local/go/src

Puedes verificar ir env:

...$# go env

¡Hurra!

GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/usr/local/go/src"
GORACE=""
GOROOT="/usr/local/go"

Ahora puede sudo and go podrá descargar y crear directorios dentro de go / src y puede llegar a lo que estaba tratando de hacer.

ejemplo

# sudo go get github.com/..

Ahora te encontrarás con otro problema ... es posible que no tengas instalado git ... esa es otra aventura ... :)

En mi máquina Fedora 20 agregué las siguientes líneas a mi ~ / .bashrc:

export GOROOT=/usr/lib/golang
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Otra solución más: exportar todas GO*las variables de entorno dego env

.bashrc:

eval $(go env | grep '^GO[A-Z0-9_]*=' | while read setenv; do
  echo "export $setenv; "
done 2> /dev/null)

[[ -n $GOPATH ]] || export GOPATH="$HOME/go/bin"
[[ -n $GOROOT ]] || export GOROOT=/usr/bin/go
export PATH="$PATH:$GOPATH/bin:$GOROOT/bin"

Edite su ~/.bash_profilepara agregar la siguiente línea:

$ export GOPATH=$HOME/work

Guarde y salga de su editor. Luego, busca tu~/.bash_profile

$ source ~/.bash_profile

Nota: Establezca la ruta GOBIN para generar un archivo binario cuando se ejecuta go install

$ export GOBIN=$HOME/work/bin

Este script te ayudará a cambiar Gopaths. https://github.com/buffonomics/goswitch

Como está escrito en las instrucciones oficiales :

La variable de entorno GOPATH especifica la ubicación de su espacio de trabajo. El valor predeterminado es un directorio llamado ir dentro de su directorio de inicio, por lo que $ HOME / go en Unix, $ home / go en el Plan 9 y% USERPROFILE% \ go (generalmente C: \ Users \ YourName \ go) en Windows. Si desea trabajar en una ubicación diferente, deberá configurar GOPATH en la ruta a ese directorio. (Otra configuración común es establecer GOPATH = $ HOME.) Tenga en cuenta que GOPATH no debe ser la misma ruta que su instalación de Go.

Entonces, por ejemplo, si está codificando en Jetbrains Webstorm (usando el complemento Go ), es posible que desee configurarlo GOPATHcomo /Users/<user>/WebstormProjects.

En palabras más simples, configúrelo donde quiera que residan sus proyectos Go.

Puede usar la solución "exportar" tal como lo han sugerido otros usuarios. Me gustaría ofrecerle otra solución para su conveniencia permanente: puede usar cualquier ruta como GOPATH cuando ejecute los comandos Go.

En primer lugar, debe descargar una pequeña herramienta llamada gost: https://github.com/byte16/gost/releases . Si usa ubuntu, puede descargar la versión de Linux ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Luego debe ejecutar los siguientes comandos para descomprimirlo:

$ cd /path/to/your/download/directory 
$ tar -xvf gost_linux_amd64.tar.gz

Conseguirías un ejecutable gost. Puede moverlo /usr/local/binpara un uso conveniente:

$ sudo mv gost /usr/local/bin

Ejecute el siguiente comando para agregar la ruta que desea utilizar como GOPATH en el espacio de ruta que gost mantiene. Es necesario darle a la ruta un nombre que usaría más adelante.

$ gost add foo /home/foobar/bar     # 'foo' is the name and '/home/foobar/bar' is the path

Ejecute cualquier comando Go que desee en el formato:

gost goCommand [-p {pathName}] -- [goFlags...] [goArgs...]

Por ejemplo, desea ejecutar go get github.com/go-sql-driver/mysqlcon /home/foobar/barGOPATH, simplemente hágalo de la siguiente manera:

$ gost get -p foo -- github.com/go-sql-driver/mysql  # 'foo' is the name you give to the path above.

Le ayudaría a configurar el GOPATH y ejecutar el comando. Pero recuerde que ha agregado la ruta en gostel espacio de ruta . Si está bajo cualquier nivel de subdirectorios de /home/foobar/bar, incluso puede ejecutar el siguiente comando que haría lo mismo para abreviar:

$ gost get -- github.com/go-sql-driver/mysql

gostes una herramienta simple de Go que puede ayudarlo a administrar GOPATHs y ejecutar comandos Go. Para obtener más detalles sobre cómo usarlo para ejecutar otros comandos Go, simplemente puede ejecutarlo gost help goCmdName. Por ejemplo, desea saber más install, simplemente escriba las palabras a continuación en:

$ gost help install

También puede encontrar más detalles en el archivo README del proyecto: https://github.com/byte16/gost/blob/master/README.md

Debe actualizar la RUTA en función del terminal (bash o zsh) que utiliza.

1. Abra el archivo de script de shell del terminal, es decir, ~/.bashrco ~/.zshrcen un editor

   vi ~/.zshrc
      (or)
   code ~/.zshrc

2. Actualice el GOPATH a continuación si ya lo encontró o agregue la línea a continuación.

export GOPATH=$HOME/go:/$HOME/projects/go

Aquí puede agregar una o más rutas separadas por un punto y coma :desde diferentes ubicaciones de sus proyectos GO en el sistema a la GOPATHvariable de entorno, es decir, /path/1:path/2:path/3etc.

En mi caso, he agregado 2 rutas, como se muestra arriba, una desde la raíz $HOME/goy la otra desde el directorio de proyectos:/$HOME/projects/go