Como DEFINIR a variável de ambiente GOPATH no Ubuntu? Que arquivo devo editar?

Estou tentando fazer um go get:

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

e falha com o seguinte erro:

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

quando eu faço a go env, uma lista de valores Go é mostrada abaixo:

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 o GOPATH não está definido, como e onde devo defini-lo?

Vejo muitos tópicos que mencionam esse erro, mas nenhum que responda à minha pergunta. Qual arquivo precisa ser editado para fornecer um valor para esse caminho?

Nova maneira:

Confira esta resposta.

À moda antiga:

Basta adicionar as seguintes linhas ao ~ / .bashrc e isso persistirá. No entanto, você pode usar outros caminhos que você gosta como GOPATH em vez de $ HOME / go na minha amostra.

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

Ubuntu 14.04

export GOPATH=$HOME/go

Além disso, você pode adicionar essa sequência ao arquivo

$HOME/.bashrc

GOPATH deve ser definido como um diretório vazio recém-criado. Este é o "espaço de trabalho", onde ele baixa pacotes, etc. Eu uso ~ / .go.

Por exemplo:

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

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

Nova maneira: Go Modules

Desde o Go 1.11, você não precisa mais usar o GOPATH. Basta ir ao diretório do projeto e fazer isso uma vez:

go mod init github.com/youruser/yourrepo

• Com isso, o Go cria uma raiz de módulo nesse diretório.
• Você pode criar quantos módulos quiser.
• Para obter instruções passo a passo, consulte também esta resposta .

Caminho Antigo: GOPATH

Se você insiste em trabalhar com o GOPATH, preste atenção:

• Desde o Go 1.8, você não precisa definir seu GOPATH ou GOROOT.
• GOPATH, por padrão, está no seu diretório de usuário / home.

A partir da documentação :

Se nenhum GOPATH estiver definido, presume-se que seja $ HOME / go nos sistemas Unix e% USERPROFILE% \ no Windows. Se você deseja usar um local customizado como área de trabalho, pode definir a variável de ambiente GOPATH.

Se, por exemplo, for um Ubuntu, após a instalação dos pacotes:

$sudo apt install golang -y

Basta adicionar as seguintes linhas ao ~ / .bashrc (do seu usuário)

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

export GOPATH=/path/desired/here

Não há necessidade de editar nenhum arquivo, podemos apenas usar o comando acima para editar diretamente as variáveis ​​de ambiente Go.

Escreva este código no terminal.

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

Nota : Isso será redefinido a cada nova janela do Terminal ou reinicialização do sistema.

Para ser persistente, cole o código abaixo no seu arquivo .zshrcou de .bashrcacordo com seu shell. Esses arquivos em seu diretório pessoal . Será como abaixo.

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

Você precisará do GOPATH mais tarde também. Então adicione-o a ~/.bashrc.

Se você configurou algo que precisa de modificação de variáveis ​​de ambiente, como Java, Go, etc, isso será muito familiar.

Assumirei que você tenha a seguinte estrutura de diretórios em algum lugar como o caminho Ir:

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

• abrir um novo terminal
• tipo sudo nano /etc/environment
• encontre PATH=...e vá até o final e adicione dois pontos :após o último caminho e cole na sua totalidade, go pathpor exemplo/home/user/gocode

e pronto, isso deve torná-lo persistente no sistema.

Foi isso que o fez funcionar para mim no Ubuntu 15.10 usando o fish shell:

# ~/.config/fish/config.fish

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

Então eu tive que alterar as permissões na gopasta (foi definida como raiz)

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

O caminho go pode estar em todos os lugares em que você deseja criar um diretório e definir a variável de caminho global no nome de GOPATH para o seu ambiente.

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

Com o Go 1.8 (Q2 2017), você não precisará editar nenhum arquivo se aceitar o GOPATHvalor padrão (definido para você)

$HOME/go

Você pode ver os comentários na edição 17262 e o voto associado no twitter :

Ao escolher um padrão GOPATH, podemos facilitar nossa documentação porque podemos dizer coisas como

$ go get github.com/foo/bar

verificará o github.com/foo/barrepo em $HOME/go/src/github.com/foo/bar.

Não precisamos distrair os recém-chegados com a definição de um env var, tudo o que precisamos fazer é colocar uma pequena nota entre parênteses na parte inferior da página

$HOME/goé o caminho padrão para o seu espaço de trabalho go.
Se você deseja alterar esse caminho, defina a GOPATHvariável como algo de sua escolha.

Meu ambiente de trabalho era semelhante ao seu.

$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"

Eu o resolvi definindo GOPATH como / usr / lib / go . Experimente.

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

GOPATH é uma variável de ambiente para a sua localização no espaço de trabalho. GOROOT é uma variável de ambiente para o diretório de instalação. Embora GOROOT e GOPATH sejam definidos automaticamente (se não houver um erro) durante o tempo de instalação, para especificá-lo manualmente, você pode seguir o processo abaixo. Além disso, para obter mais informações, consulte a página wiki do GO .

É melhor definir GOPATH como um diretório dentro do seu diretório pessoal, por exemplo, $ HOME / go,% USERPROFILE% \ go (Windows).

1. Esta é uma solução mac, testada no macOS Sierra, ver. 10.12, e também no Gogland-EAP, que foi introduzido como uma programação IDE for Go pelo JetBrains.

No seu tipo de terminal

vim ~/.profile

no documento aberto no Terminal, pressione i e adicione o seguinte caminho

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

pressione ESC e digite : x . Por fim, você deve reiniciar ( fechar e abrir ) seu terminal ou Logout e Login novamente.

2. Para configuração do Windows e Linux, consulte a página da wiki Go em Githab, em Setting GOPATH-Golang .

CUIDADO Não defina GOROOT e GOPATH no mesmo diretório, caso contrário, você receberá um aviso.

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

E você pode verificar por $ go env

(Ubuntu)

Se você não definir um GOPATH, o padrão será usado.

Você precisa adicionar $ GOPATH / bin ao seu PATH para executar qualquer binário instalado em $ GOPATH / bin ou precisa digitar $ GOPATH / bin / the-command. Adicione isso ao seu ~ / .bash_profile

export PATH=$GOPATH/bin:$PATH

Comando atual do GOPATH:

go env GOPATH

Alterando o comando GOPATH:

export GOPATH=$HOME/your-desired-path

Essa tem sido a coisa mais irritante de se lidar. Na esperança de economizar seu tempo.

IF go foi instalado como usuário root. O usuário root do arquivo de texto bash_profile do sistema ~ / .bash_profile precisa ter $ GOROOT designado ao diretório go install e $ GOPATH precisa ser designado ao diretório 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]
    ...

verifique se o caminho a ser binário está no seu caminho em .bash_profile

PATH = $ PATH: $ HOME / bin: / usr / local / bin: / usr / local / go / bin

Esse PATH pode ter o tamanho de uma string que precisa ser .. para adicionar novos itens, basta separar dois pontos:

saia do editor vi e salve o perfil do bash (: wq significa write and quit)

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

Você precisa sair do terminal e fazer login novamente para que o perfil seja iniciado novamente .. ou você pode simplesmente iniciar usando a exportação.

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

Você pode verificar go env:

...$# go env

Yay!

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

Agora você pode sudo and go, poderá baixar e criar diretórios dentro de go / src, e você pode se concentrar no que estava tentando fazer.

exemplo

# sudo go get github.com/..

Agora você terá outro problema ... talvez não tenha o git instalado .. essa é outra aventura .. :)

Na minha máquina Fedora 20, adicionei as seguintes linhas ao meu ~ / .bashrc:

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

Outra solução: exporte todas GO*as variáveis ​​de ambiente 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 seu ~/.bash_profilepara adicionar a seguinte linha:

$ export GOPATH=$HOME/work

Salve e saia do seu editor. Em seguida, obtenha seu~/.bash_profile

$ source ~/.bash_profile

Nota: Defina o caminho GOBIN para gerar um arquivo binário quando a instalação for executada

$ export GOBIN=$HOME/work/bin

Este script irá ajudá-lo a mudar os Gopaths. https://github.com/buffonomics/goswitch

Conforme escrito nas instruções oficiais :

A variável de ambiente GOPATH especifica a localização do seu espaço de trabalho. O diretório padrão é ir dentro do diretório inicial; portanto, $ HOME / vá para Unix, $ home / vá para o Plano 9 e% USERPROFILE% \ go (geralmente C: \ Users \ YourName \ go) no Windows. Se você deseja trabalhar em um local diferente, precisará definir GOPATH no caminho para esse diretório. (Outra configuração comum é definir GOPATH = $ HOME.) Observe que GOPATH não deve ter o mesmo caminho que a instalação do Go.

Por exemplo, se você estiver codificando no Jetbrains Webstorm (usando o plug-in Go ), convém definir GOPATHcomo /Users/<user>/WebstormProjects.

Em palavras mais simples, defina-o onde quiser que seus projetos Go residam.

Você pode usar a solução "export" exatamente como o que outros caras sugeriram. Gostaria de fornecer outra solução para conveniência permanente: você pode usar qualquer caminho como GOPATH ao executar os comandos Go.

Primeiramente, você precisa baixar uma pequena ferramenta chamada gost: https://github.com/byte16/gost/releases . Se você usa o ubuntu, pode baixar a versão linux ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Então você precisa executar os comandos abaixo para descompactá-lo:

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

Você obteria um executável gost. Você pode movê-lo /usr/local/binpara um uso conveniente:

$ sudo mv gost /usr/local/bin

Execute o comando abaixo para adicionar o caminho que você deseja usar como GOPATH no espaço de caminho gost mantém. É necessário dar ao caminho um nome que você usaria posteriormente.

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

Execute qualquer comando Go desejado no formato:

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

Por exemplo, você deseja executar go get github.com/go-sql-driver/mysqlcom /home/foobar/barcomo o GOPATH, apenas fazê-lo como abaixo:

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

Ajudaria você a definir o GOPATH e executar o comando. Mas lembre-se de que você adicionou o caminho no espaço gostde caminhos do . Se você estiver em qualquer nível de subdiretórios de /home/foobar/bar, você pode até mesmo executar o comando abaixo, que faria o mesmo em breve:

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

gosté uma ferramenta simples de Go, que pode ajudá-lo a gerenciar GOPATHs e executar comandos Go. Para mais detalhes sobre como usá-lo para executar outros comandos Go, você pode simplesmente executar gost help goCmdName. Por exemplo, para saber mais install, basta digitar as palavras abaixo em:

$ gost help install

Você também pode encontrar mais detalhes no README do projeto: https://github.com/byte16/gost/blob/master/README.md

Você precisa atualizar o PATH com base no terminal (bash ou zsh) usado.

1. Abra o arquivo de script shell do terminal, ~/.bashrcou seja, ~/.zshrcem um editor

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

2. Atualize o GOPATH abaixo, se já encontrado, ou adicione a linha abaixo.

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

Aqui você pode adicionar um ou mais caminhos separados por ponto e vírgula :de diferentes locais dos seus projetos GO no sistema à GOPATHvariável de ambiente, ou seja, /path/1:path/2:path/3etc.

No meu caso, adicionei 2 caminhos, como mostrado acima, um da raiz $HOME/goe outro do diretório de projetos:/$HOME/projects/go