5 minutos de lectura

Resumen

Go te ayuda a crear backends más rápidos y escalables, y esta guía te mostrará cómo conectar tu backend a Ethereum (y hacerlo aún más rápido, más fiable y accesible a nivel mundial, todo ello gracias a la infraestructura global de Quicknode). 

¿Qué es GoLang?

Go es un lenguaje de programación de código abierto creado por ingenieros de Google en 2009. Se deriva en parte del lenguaje C, del que adopta la sintaxis y las características, pero incorpora seguridad de memoria, recolección de basura, tipado estructural y concurrencia. Go cuenta con mecanismos de concurrencia sumamente eficientes que aprovechan al máximo el hardware multinúcleo moderno, así como las infraestructuras de red distribuidas.

Características principales de Go:

1. De tipado estático y compilación rápida, genera ejecutables binarios —que son RÁPIDOS—
2. Multiplataforma y compatible con dispositivos móviles: funciona en la mayoría de las plataformas y cuenta con bibliotecas nativas 
3. Sólido soporte para la concurrencia con primitivas integradas. Utiliza goroutines, que consumen muy poca memoria, ofrecen un tiempo de arranque rápido y permiten ejecutar múltiples subprocesos.
4. Sencillo y minimalista (la referencia completa solo tiene 50 páginas)
5. Una biblioteca estándar sólida con numerosos complementos
6. Punteros y parámetros por referencia: ¿no los echas de menos?

Conectarse a Ethereum con Geth, también conocido como go-ethereum

go-ethereum es la implementación oficial de Ethereum en Go (también conocida como Geth); el paquete ethclient se puede utilizar para la API RPC de Ethereum.

Requisitos previos

• Tener instalada la versión 1.13 o superior de Go
• Un editor de texto
• CLI

Cómo instalar Go y gestión básica de errores

Como ya se ha mencionado, si queremos utilizar el cliente go-ethereum, tendremos que comprobar si Go está instalado en tu sistema:

$ go version

Si Go no está instalado, sigue la guía de instalación oficial correspondiente a tu sistema operativo específico.

Asegúrate de que también tienes instalado el compilador gcc.
Para Ubuntu: utiliza «apt-get install build-essentials»
Para Windows: utiliza «https://jmeubank.github.io/tdm-gcc/download/»
Para Mac: utiliza Homebrew

$ brew instalar gcc

Otra opción más rápida es descargar las herramientas de línea de comandos de Xcode utilizando 

$ xcode-select --install

Si no estás familiarizado con Go, te recomendamos que sigas su tutorial interactivo, que abarca la sintaxis básica, los métodos y la gestión de la concurrencia. Hay varios ejercicios que puedes realizar sin tener que salir de tu entorno. Solo tienes que escribir el siguiente comando en la línea de comandos o en la terminal para ejecutar el tutorial de forma local:

$ go get golang.org/x/tour

Ahora escribe:

$ tour

Configura tu punto de acceso de Quicknode

Para los fines de esta guía, se puede utilizar cualquier nodo de Ethereum: Geth u OpenEthereum (antes conocido como Parity). Para simplificar, crearemos una cuenta en Quicknode aquí y configuraremos un punto de conexión de Ethereum. Una vez que hayas creado tu punto de conexión gratuito de Ethereum, copia la URL del proveedor HTTP, ya que la necesitarás más adelante. Quicknode hace que poner en marcha, ejecutar y mantener tu propio nodo sea una experiencia muy sencilla. Los desarrolladores ya no tienen que esperar días a que se complete la sincronización, sacrificar terabytes de espacio de almacenamiento ni preocuparse por la seguridad y el mantenimiento.

Lo vas a necesitar más adelante, así que cópialo y guárdalo.

Conectarse a través de Go

A continuación te explicaremos cómo inicializar tu proyecto en Go, conectarte a la red de Ethereum y obtener el número del último bloque de forma rápida, sencilla y sin complicaciones, siempre que tengas instalada la última versión de Go en tu entorno. 

1. Crea un archivo llamado quiknode.go 

package main

import (
	"fmt"
	"log"
	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {

	_, err := ethclient.Dial("ADD_YOUR_ETHEREUM_NODE_URL")

	if err != nil {
		log.Fatalf("Oops! There was a problem", err)
	} else {
		fmt.Println("Success! you are connected to the Ethereum Network")
	}
}

Sustituye `ADD_YOUR_ETHEREUM_NODE_URL` por el punto final del proveedor que has guardado anteriormente.

2. Crea un módulo para gestionar las dependencias. Si no estás familiarizado con Go, este es un paso esencial para configurar las dependencias de tu proyecto. Con Go es bastante fácil.

Solo tienes que escribir:

$ go mod init quiknode

De este modo, te asegurarás de que el ethclient incluido en tu código se descargue de GitHub y se instale localmente. El proceso se realiza de forma automática y la última versión debería incorporarse a tu entorno junto con los módulos Go integrados. 

Si tienes algún problema con la instalación de ethclient, también puedes descargarlo con el siguiente comando:

$ go get github.com/ethereum/go-ethereum/ethclient

3. Ejecuta tu módulo con 

$ go run quiknode.go

Si todo va bien, aparecerá el siguiente mensaje:

¡Qué fácil ha sido! Ya tienes en marcha tu propio nodo, que está conectado y sincronizado. A continuación, comprueba si tu nodo funciona y recupera algo de información de la cadena de bloques.

4. Modifica tu código para obtener información adicional de la cadena de bloques de ETH:

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("ADD_YOUR_ETHEREUM_NODE_URL")
   
    if err != nil {
        log.Fatalf("Oops! There was a problem", err)
    } else {
        fmt.Println("Sucess! you are connected to the Ethereum Network")
    }
    
    header, err := client.HeaderByNumber(context.Background(), nil)
    if err != nil {
        log.Fatal(err)
    } else {
        fmt.Println(header.Number.String())
    }
}

 Una breve explicación del código anterior:

Líneas 1-9: Declaración del paquete principal y adición de las dependencias necesarias para conectarse a la cadena de bloques.
Línea 11: Llamada a la función principal. Línea 12: Configuración de nuestro cliente y conexión al mismo a un nodo de Ethereum alojado en Quicknode. Línea 14: Comprobación de errores de conexión.
Línea 18: Visualización de un mensaje indicando que la conexión se ha realizado correctamente.
Línea 20: Envío de una solicitud a nuestro nodo para obtener el número del último bloque.
Líneas 21-26: Comprobación de errores en la solicitud y visualización de un mensaje de éxito si no hay errores; conversión del número hash a una cadena de caracteres y visualización de la misma.

No olvides sustituir `ADD_YOUR_ETHEREUM_NODE_URL` por la dirección del punto final HTTP de tu propio nodo. 

Una vez ejecutado correctamente, verás un mensaje similar a este:

¡Y ya está! Ahora ya puedes utilizar tu propio Quicknode y crear la próxima dApp alucinante con Go.

Conclusión

En esta guía te hemos mostrado cómo conectarte a la red de Ethereum utilizando Go y un nodo gratuito de Ethereum de QuikNode. Te animamos a que obtengas más información sobre los distintos métodos RPC de ethclient en su documentación y a que explores el repositorio de GitHub de go-ethereum para descubrir otros módulos.

Además, descubre cómo poner en marcha tu propio nodo go-ethereum/geth en nuestro tutorial«Cómo instalar y ejecutar un nodo Geth».

Suscríbete a nuestro boletín para recibir más artículos y guías de QuikNode sobre Ethereum. Comparte tus comentarios en Twitter y pregúntanos lo que quieras en Discord.