Instalar Go en Linux

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

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

😎

Resumen

1. Descargar la ultima versión de go desde su pagina oficial https://golang.org/dl/

2. Descomprimir el archivo tar.gz en el directorio /usr/local

3. En home modificar el archivo .bashrc con visual studio code o cualquier otro editor de texto. Añadiremos las siguientes líneas al final del archivo:

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

   nota: $HOME= /home/nombre-del-usuario

4. para ejecutar los cambios realizados usa . .bashrc en el home o también funciona abrir una nueva terminal

5. verificar que go este funcionando correctamente con go version

6. en nuestro home crear la carpeta go y dentro de estas las subcarpetas bin pkg src

para generar el entorno de directorios para go

mkdir -p $HOME/go/{bin,pkg,src}

Muchachos, solo deseo que quienes estén pasando por acá, recuerden que el futuro lo tenemos en nuestras manos y hay mucho por hacer, nunca desistan

Yo instale Go hace tiempo en ubuntu, como no sabia lo que se muestra en el video solamente escribi en la terminal “go” y me dio la recomendacion de instalarlo mediante apt sin tener que hacer configuraciones.
Es una buena forma de iniciar o tambien esta la opcion de https://play.golang.org/

Para usuarios de Archlinux (o derivados) simplemente hay que escribir este comando en la terminal:

sudo pacman -S go

Listo, instalado en Windows10 con el subsistema de linux Ubuntu.

Si estan en Debian o en algun derivado(ejm: Ubuntu) pueden simplemente hacer :

sudo apt install golang-go

De esta forma ya no tienen que hacer ninguna configuración extra 😄

Si estas usando el shell zsh entonces debes hacer la connfiguracion dentro de ~/.zshrc y al terminar teclear:

source ~/.zshrc

Asi no tendras que cerrar y abrir la terminal.

Hola, así como existe nvm para poder administrar con facilidad las versiones de node.js en nuestro sistema, tambien existe gvm para Go, sin embargo yo les recomiendo goup que en lo personal me gusta mas y solo ocupo tener esto en mis variables de entorno:

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

Solo una linea, nada mas.

Hola a todos, les dejo un link relativo a la edición del archivo .bashrc

https://ubunlog.com/bashrc-modifica-prompt-bash/

Saludos

La verdad un mal video, no explico nada, solo se grabo haciendo el procedimiento, tuve que salir a buscar en youutube como instalarlo porque en serio no explico nada, y no fui el unico, en los comentarios se nota que a muchos compañeros les ocurrio lo mismo

instalando linux en WSL…
https://www.youtube.com/watch?v=0e_C1B8fDvg

Les recomiendo montar su ambiente de esta forma en WSL/WIN para evitar montar una VM:
https://www.youtube.com/watch?v=poejKP1wTpc&t=1853s&ab_channel=NicJackson

hi gente, les traigo la instalación en la WSL 2 por si la requieren, good vibes!!!.
https://medium.com/@benzbraunstein/how-to-install-and-setup-golang-development-under-wsl-2-4b8ca7720374

personalmente recomiendo este video. para instalar en ubuntu. https://www.youtube.com/watch?v=E1yiCT2Rdj8

No se si a alguien le sirva, pero yo usé Docker con Vs Code para configurar mi ambiente de desarrollo, desde que aprendí a usarlo no me gusta instalar nada localmente 😅, me costó un poco configurar todo para usar un usuario no root, asi que aqui dejo la declaración de la imagen que use, quizás a algún otro amante de Docker que esté aprendiendo Go le pueda servir de algo. 😬

Hay que cambiar golang_tests por el nombre del workspace de Vs Code para que funcione bien.

FROM golang:1.17rc2

ARG USERNAME=development
ARG WORKDIR=/workspaces/golang_tests

RUN useradd -ms /bin/bash $USERNAME

RUN mkdir -p $WORKDIR

RUN mkdir -p $WORKDIR/go/bin
RUN mkdir -p $WORKDIR/go/pkg
RUN mkdir -p $WORKDIR/go/src

COPY [".","$WORKDIR"]

RUN find "$WORKDIR/" -type d -exec chmod 755 {} \;
RUN find "$WORKDIR/" -type f -exec chmod 755 {} \;

ENV GOPATH="$WORKDIR/go"
ENV GOBIN="$GOPATH/bin"
ENV GOROOT="/usr/local/go"

ENV PATH="$PATH:$GOBIN:$GOROOT/bin"

RUN chown -R $USERNAME $WORKDIR
RUN chmod 755 $WORKDIR

WORKDIR $WORKDIR
USER $USERNAME

En Windows.

C:\Users\chris\OneDrive\Documentos\go>go version
go version go1.17.1 windows/amd64

C:\Users\chris\OneDrive\Documentos\go>dir
 El volumen de la unidad C es OS
 El número de serie del volumen es: F2FF-D8B3

 Directorio de C:\Users\chris\OneDrive\Documentos\go

20/09/2021  15:58    <DIR>          .
20/09/2021  15:57    <DIR>          ..
20/09/2021  15:58    <DIR>          bin
20/09/2021  15:58    <DIR>          pkg
20/09/2021  15:58    <DIR>          src
               0 archivos              0 bytes
               5 dirs  23,620,251,648 bytes libres

👾 Podemos comprobar la versión de Go instalada en nuestro computador, utilizando el siguiente comando:

go version

Como dato, gracias a go modules ya no es necesario poner nuestro codigo en la carpeta src, pero eso se ve mas a delante

Las carpetas creadas dentro de la ruta /home/your_username/go sirven para lo siguiente:

• bin Guarda todos los binarios o executables creados en Go.
• pkg Guarda codigo que depende de los Go Modules o dependencias que se utilicen.
• src Tiene dos funciones. La primera es escribir todo el código desarrollado en Go y la segunda es guardar el conjunto de codigo de librerías de terceros instaladas.

<zypper in go> 

en opensuse

Otra forma de instalar y de que siempre este actualizado es usar:

sudo snap install go --classic 

Esto funciona para distros que viene de Ubuntu/Debian

Hay una forma de instalar GO desde la terminal y es
sudo apt install golang-go

Personalmente me parece mas facil usar un manejador de paquetes o package manager

Algunos ejemplos para algunas distribuciones de Linux son:

Ubuntu-Basadas en Ubuntu-Debian: apt

sudo apt install go

Manjaro: pamac

sudo pamac install go

Arch: pacman

sudo pacman -S go

Solo ejecutas el comando correspondiente a tu distribucion y listo, el se encarga de lo demas

Una vez en home podemos ejecutar el sigueinte comando para crear todas las carpeta de una sola vez:
mkdir go && cd go && mkdir bin pkg src

nano ~/.bashrc

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

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

source ~/.bashrc

$ sudo apt install golang.

Malo, se salta pasos y no se explica bien.
Espero que en las siguientes clases sea mejor.

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

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

<code>

Por si no le entendieron muy bien para qué sirve pkg, este folder guarda Go Packages que son objetos compilados que vienen del folder src. Luego estos packages los pueden incluir y usar dentro del código, para que al momento de compilar, se vincule el ejecutable dentro de pkg a nuestro ejecutable en sí.

Por ejemplo, si estamos haciendo una app que calcule cuánto costará reparar un carro, y ya tenemos un package que genera el presupuesto, este código compilado estaría dentro de pkg, y nosotros podemos incluir este package dentro de nuestro script para usar el generador de presupuestos. Cuando compilemos nuestro código, el package se va a vincular y así únicamente compilamos lo que escribimos, sin necesidad de recompilar el package.

en el video no se explica como abrir el archivo a editar, en esta pagina pueden ver paso a paso como instalar go https://golangdocs.com/install-go-linux

También es posible utilizar un gestor de versiones para Go desde este enlace gvm

Golang _

exportar PATH de go

Para instalarlo en Amazon Linux sólo basta con

sudo yum install golang -y
go version

En la documentación de Go indican ejecutar este comando para descomprimir los archivos descargados

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.16.6.linux-amd64.tar.gz

sin embargo tengan en cuenta que se deben ejecutar con el comando sudo para tener los permisos suficientes en la carpeta /usr/local, adicional tener en cuenta que son dos comandos anidados por una condicional, en conclusión se debe ejecutar:

sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.16.6.linux-amd64.tar.gz

Creamos dentro del home, la carpeta go: Dentro de ella, creamos bin, para guardar nuestros ejecutables y de terceros también. Luego pkg, para guardar algunas partes del código de las librerías que vayas a utilizar y por útlimo scr, para guardar todo el código que vayamos a desarrollar en GO y guardar otro código de liberías de terceros.

Si tienes z shell, entonces solo tienes que poner, en el archivo, .zshrc : export GOPATH=$HOME/go export GOBIN=$GOPATH/bin export GOROOT=/usr/local/go export PATH=$PATH:$GOBIN:$GOROOT/bin... Lo mismo que el profe.

Go es mejor en Linux xD. Así que sí, utiliza Linux.

sudo apt install golang

Instalacion:
Luego de instalar, editar .bashrc, agregando al final:

# GOPATH es el entorno en el cual voy a desarrollar mis programas
export GOPATH=/home/usuario/go

# GOBIN es donde se van a instalar los binarios listos para ser ejecutados en cualquier path
export GOBIN=$GOPATH/bin

# GOROOT indica al runtime donde esta el ejecutador de Go
export GOROOT=/usr/local/go

# Luego las agregamos al path
export PATH=$PATH:$GOBIN:$GOROOT/binarios

Luego, dentro de /home/usuario/go crear tres carpetas:
/bin
/pkg
/src

Instalar GO en WSL de manera sencilla y rápida:
https://www.youtube.com/watch?v=0e_C1B8fDvg

Configuración en archivo .bashrc o .zshrc para poder hacer uso de Go desde la terminal

Recuerden añadir esto a su ~/.bashrc :

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

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

A mi parecer la forma mas facil de añadirlo es con:

vim  ~/.bashrc

Pero pueden usar el editor que quieran 😄

Para los que tienen Debian o derivado. Pueden instalar Go con el clásico y tradicional:
sudo apt install golang-go

Y si utilizan el gestor de paquetes Snap, pueden instalarlo con
sudo snap install go

Y listo, sin configuraciones extra.