Cómo instalar el lenguaje de programación Go en Linux (Ubuntu/Debian/CentOS)
Go, también conocido como Golang, es un lenguaje de programación de código abierto diseñado por Google para ser rápido, fácil, eficiente y escalable. Go es un lenguaje de programación moderno que facilita el desarrollo de software simple, confiable y eficiente. Muchas herramientas populares de DevOps están integradas en el go lenguaje de programación, incluyendo Docker, Kubernetes, Terraform, Grafana y Hoshicorp Vault.
Este tutorial le guiará paso a paso sobre cómo instalar el lenguaje de programación Go en un sistema Linux. Con esta guía, podrá instalar Go en diferentes distribuciones de Linux, como Debian 10, Ubuntu 18.04 y CentOS 7.
Lo que haremos:
- Descargue la última versión estable de Go
- Configurar el entorno del sistema para Go
- Pruebas – Hola mundo
Paso 1: Descargue la última versión estable de Go
Para comenzar con la instalación de Go (lenguaje de programación) en su sistema Linux, primero debe descargar la última versión de Go, la versión ‘1.13’, utilizando el siguiente comando wget:
wget https://dl.google.com/go/go1.13.linux-amd64.tar.gz
Una vez completada la descarga, verifique el archivo tarball descargado utilizando el siguiente comando para asegurarse de que la descarga sea correcta y segura:
sha256sum go1.13.linux-amd64.tar.gz
Debe recibir un hash de suma de comprobación ‘sha256’ similar al siguiente:
68a2297eb099d1a76097905a2ce334e3155004ec08cdea85f24527be3c48e856 go1.13.linux-amd64.tar.gz
A continuación, extraiga el archivo tarball de Go en el directorio ‘/usr/local’ para instalar el lenguaje de programación Go en su sistema:
tar -C /usr/local -xzf go1.13.linux-amd64.tar.gz
Con esto, el paquete binario de Go se instalará en el directorio ‘/usr/local/go’.
Paso 2: Configurar el entorno del sistema para Go
Después de descargar e instalar el paquete binario de Go, es esencial configurar el entorno del sistema para el lenguaje de programacion Go en Linux. Para usuarios que trabajan con bash, pueden editar el archivo ‘.bash_profile’, mientras que para usuarios de zsh, el archivo correspondiente es ‘.zprofile’.
Para usuarios de Debian y Ubuntu
Los usuarios de Debian y Ubuntu deberán editar o crear el archivo ‘~/.bash_profile’ en su directorio de inicio para el linux lenguaje de programacion Go.
Abra el archivo ‘~/.bash_profile’ con su editor preferido, como vim:
vim ~/.bash_profile
Incorpore la siguiente configuración del entorno para Go:
export GOPATH=$HOME/work export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
Guarde y cierre el archivo.
Para que la configuración se cargue en cada inicio de sesión, debe incluirla en el archivo ‘~/.bashrc’:
Abra el archivo ‘~/.bashrc’ con vim:
vim ~/.bashrc
Agregue la siguiente línea al final del archivo:
source ~/.bash_profile
Guarde y cierre el archivo.
Después de guardar los cambios, cierre la sesión de su shell y vuelva a iniciarla para que las nuevas variables de entorno tomen efecto.
Para usuarios de CentOS 7
Para usuarios de CentOS 7, el proceso de configuración de las variables de entorno para el lenguaje de programación go es similar. Edite el archivo ‘~/.bash_profile’ y luego cargue la nueva configuración manualmente:
Abra el archivo con vim:
vim ~/.bash_profile
Inserte las siguientes líneas que definen las variables del entorno Go:
export GOPATH=$HOME/work export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
Guarde y cierre el archivo.
Cargue la nueva configuración manualmente con el comando source:
source ~/.bash_profile
Con esto, las variables de entorno para Go estarán disponibles en su sesión de CentOS.
Para usuarios de ZSH
Los usuarios de zsh deberán agregar la configuración del entorno del sistema al archivo ‘~/.zprofile’:
Cree o edite el archivo ‘~/.zprofile’ con su editor preferido:
vim ~/.zprofile
Agregue las siguientes líneas para configurar el entorno Go:
export GOPATH=$HOME/work export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
Guarde y cierre el archivo.
Al iniciar sesión nuevamente, la configuración de ZSH cargará automáticamente las nuevas variables de entorno.
Crear el directorio de trabajo
Después de configurar las variables de entorno para Go, es necesario crear el directorio de trabajo de Go en su directorio de inicio:
mkdir -p $HOME/work
Verifique que el entorno esté configurado correctamente con los siguientes comandos:
echo $GOPATH echo $PATH
Debería ver que ‘$GOPATH’ corresponde al directorio de trabajo de Go y que la ruta binaria de Go se ha agregado al entorno ‘$PATH’.
A continuación, confirme que puede ejecutar los siguientes comandos de Go:
go version go --help
Si estos comandos funcionan, significa que ha configurado con éxito el entorno de Go en su sistema Linux.
Además: Establezca la variable de entorno Go en todo el sistema
Para configurar la variable de entorno de Go en todo el sistema para todos los usuarios que utilizan el shell Bash, deberá definir la variable de entorno en el directorio ‘/etc/profile.d’. Este procedimiento es el mismo para todas las distribuciones principales de Linux que utilizan bash como shell predeterminado, incluidos Debian, Ubuntu y CentOS.
Navegue al directorio ‘/etc/profile.d’ y cree un nuevo archivo de configuración ‘go.sh’:
cd /etc/profile.d/ vim go.sh
Inserte las siguientes variables de entorno para Go:
export GOPATH=$HOME/work export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
Guarde y cierre el archivo, luego haga que el archivo sea ejecutable:
chmod +x /etc/profile.d/go.sh
Con esto, todos los usuarios del sistema que utilizan Bash como shell podrán ejecutar comandos de Go de forma predeterminada.
Paso 3 – Prueba – Hello Go
Para probar la instalación de Go, crearemos un programa simple de «Hello World». Utilizaremos ‘$GOPATH’ como el directorio de trabajo principal.
Navegue al directorio de trabajo ‘$GOPATH’ y cree nuevos directorios ‘src’ y ‘bin’:
cd $GOPATH mkdir -p src/ bin/
A continuación, cree un nuevo directorio de proyecto llamado ‘hello’ dentro de ‘src’ y acceda a él:
mkdir -p src/hello/ cd src/hello/
Cree el archivo Golang ‘hello.go’ con su editor de texto:
vim hello.go
Escriba el siguiente script simple de Go:
package main
import "fmt"
func main() {
fmt.Println("Hello World, Go")
}
Guarde y salga del editor.
Luego compile el programa ‘hello.go’ en el directorio ‘$GOPATH/bin’ con el siguiente comando:
go build -o $GOPATH/bin/hello hello.go
Ahora el programa compilado llamado ‘hello’ estará disponible en el directorio ‘$GOPATH/bin’, y podrá ejecutarlo directamente desde la línea de comandos:
hello
Obtendrá la salida «Hello World, Go» en su pantalla, lo que indica que Go está correctamente instalado y configurado en su sistema Linux.
Como resultado, la instalación de Go en su sistema Linux se ha completado con éxito y está listo para comenzar a programar en este poderoso lenguaje de programación go.