Hacer un servicio con gRPC y go-zero

Hagamos un hola mundo con go-zero utilizando gRPC. Para empezar vamos a hacer el archivo .proto : 

syntax = "proto3";

package hello;

option go_package = "./hello";

message Request {

}

message Response {

  string msg = 1;

}

service Hello {

  rpc Ping(Request) returns(Response);

}

$ goctl rpc protoc hello.proto --go_out=server --go-grpc_out=server --zrpc_out=server

Done.

luego hacemos : 

cd server

go mod tidy 

Completamos el archivo server/internal/logic/pinglogic.go

func (l *PingLogic) Ping(in *hello.Request) (*hello.Response, error) {

return &hello.Response{ Msg: "pong" }, nil

}

y luego en el archivo server/etc/hello.yaml agregamos que estamos trabajando en modo dev: 

Name: hello.rpc

ListenOn: 0.0.0.0:8080

Mode: dev

y por ultimo corremos el proyecto: 

go run hello.go

Primera API con Go-zero

Después de completar la instalación de goctl, podemos crear un servicio HTTP mínimo para obtener una descripción general del servicio API go-zero de goctl.

# Create workspaces and enter the directory

$ mkdir -p ~/workspace/api && cd ~/workspace/api

# Execute instructions generated demo service

$ goctl api new demo

Done.

Después de ejecutar la instrucción, se generará un directorio de demostración en el directorio actual que contiene un servicio HTTP minimizado, verificaremos la estructura del directorio del servicio.

$ cd ~/workspace/api/demo

$ ls

demo.api demo.go  etc      go.mod   internal

$ tree

.

├── demo.api

├── demo.go

├── etc

│   └── demo-api.yaml

├── go.mod

└── internal

    ├── config

    │   └── config.go

    ├── handler

    │   ├── demohandler.go

    │   └── routes.go

    ├── logic

    │   └── demologic.go

    ├── svc

    │   └── servicecontext.go

    └── types

        └── types.go

Después de completar la generación del código anterior, podemos encontrar los archivos ~/workspace/api/demo/internal/logic/demologic.go, y podemos completar el códigos entre las líneas 27 y 28:

resp = new(types.Response)

resp.Message = req.Name

Después de escribir el código anterior, podemos iniciar el servicio con las siguientes instrucciones:

# Enter service directory

$ cd ~/workspace/api/demo

# to organize dependencies

$ go mod tidy

# Run go program

$ go run demo.go

Cuando vea el siguiente resultado "Starting server at 0.0.0.0.0:888.." indica que el servicio se ha iniciado correctamente, entonces visitamos el servicio HTTP.

$ curl --request GET 'http://127.0.0.0.1:8888/from/me'

Cuando vea el resultado en la terminal {"message":"me"} en nombre de su servicio se inició con éxito.

Y listo!!

Dejo link: https://go-zero.dev/en/docs/tasks/cli/api-demo

Instalando go zero

 

Ya hemos hablado de zero el framework de go para hacer microservicios. Ahora vamos a bajar las herramientas para trabajar con él. 

Primero, tenemos que tener go instalado. Yo tengo la versión 1.22.0

$ go version

go version go1.22.0 linux/amd64

Después de la versión 1.11, se recomienda que el valor GO111MODULE se establezca en on para evitar errores innecesarios.

$ go env -w GO111MODULE=on

$ go env -w GOPROXY=https://goproxy.cn,direct

$ go env GO111MODULE

on

$ go env GOPROXY

https://goproxy.cn,direct

goctl es una herramienta incorporada de go-zero que es importante para aumentar la eficiencia del desarrollo, generar código, documentos, implementar k8s yaml, dockerfile, etc.

$ go install github.com/zeromicro/go-zero/tools/goctl@latest

go: downloading github.com/gookit/color v1.5.4

go: downloading github.com/withfig/autocomplete-tools/integrations/cobra v1.2.1

go: downloading github.com/spf13/cobra v1.8.0

...

$ goctl -version

goctl version 1.6.2 linux/amd64

Ahora tenemos que installar docker. Yo ya tengo docker instalado por lo tanto siguo: 

$ sudo docker pull kevinwan/goctl

$ sudo docker run --rm -it -v `pwd`:/app kevinwan/goctl goctl --help

Y si todo anda bien hacemos : 

$ sudo docker run --rm -it -v `pwd`:/app kevinwan/goctl:latest goctl --version

goctl version 1.3.5 linux/amd64

protoc es una herramienta para generar código basado en archivos proto, este genern código en múltiples lenguajes como C++, Java, Python, Go, PHP, etc. para nuestros servicios gRPC. Lo tenemos que instalar, en mi caso yo lo tenia instalado y lo sé porque hice : 

$ goctl env check --install --verbose --force

[goctl-env]: preparing to check env

[goctl-env]: looking up "protoc"

[goctl-env]: "protoc" is installed

[goctl-env]: looking up "protoc-gen-go"

[goctl-env]: "protoc-gen-go" is installed

[goctl-env]: looking up "protoc-gen-go-grpc"

[goctl-env]: "protoc-gen-go-grpc" is installed

[goctl-env]: congratulations! your goctl environment is ready!

Y ahora por fin, vamos a crear nuestro proyecto go-zero!! 

Creamos el proyecto: 

$ mkdir myapp && cd myapp

$ go mod init myapp

$ go get github.com/zeromicro/go-zero@latest

go: added github.com/zeromicro/go-zero v1.6.2

Y Listo!! 

¿Qué es Go-Zero?

 

En el mundo del desarrollo de software, la velocidad, la eficiencia y la simplicidad son pilares fundamentales. El framework Go-Zero emerge como una solución poderosa para aquellos que buscan crear aplicaciones escalables y de alto rendimiento utilizando el lenguaje de programación Go (Golang).

Pero ¿Qué es Go-Zero? Go-Zero es un framework moderno y de código abierto diseñado para acelerar el proceso de desarrollo de aplicaciones en Go. Ofrece una arquitectura robusta y flexible, proporcionando herramientas y patrones que permiten construir aplicaciones web, API y microservicios de manera eficiente.

Características Principales:

• Alto rendimiento: Go-Zero se destaca por su capacidad para manejar cargas de trabajo intensivas y mantener un alto rendimiento incluso en entornos de gran escala.
• Productividad mejorada: Proporciona abstracciones y utilidades que reducen la complejidad del código, permitiendo a los desarrolladores enfocarse en la lógica de negocio en lugar de detalles de implementación.
• Facilidad de uso: Con una curva de aprendizaje amigable, su estructura modular y su amplia documentación, Go-Zero facilita a los desarrolladores tanto principiantes como experimentados.
• Soporte para microservicios: Ofrece herramientas específicas para la construcción de arquitecturas de microservicios, simplificando la comunicación entre ellos y la gestión de datos distribuidos.

Veamos un ejemplo básico de cómo se podría crear un servidor HTTP simple utilizando el framework Go-Zero:

package main

import (

"github.com/tal-tech/go-zero/core/conf"

"github.com/tal-tech/go-zero/rest"

"github.com/tal-tech/go-zero/rest/httpx"

)

type Request struct {

Name string `form:"name"`

}

type Response struct {

Message string `json:"message"`

}

func helloHandler(w httpx.ResponseWriter, r *httpx.Request) {

var req Request

if err := r.ParseForm(&req); err != nil {

w.Error(httpx.BadRequest(err.Error()))

return

}

resp := Response{

Message: "Hello, " + req.Name + "!",

}

w.WriteJson(resp)

}

func main() {

var c rest.RestConf

conf.MustLoad("path/to/config.yaml", &c)

server := rest.MustNewServer(c)

server.AddRoute(rest.Route{

Method:  "GET",

Path:    "/hello",

Handler: helloHandler,

})

defer server.Stop()

server.Start()

}

Go-Zero representa una opción valiosa para aquellos que buscan desarrollar aplicaciones en Go de manera rápida, eficiente y escalable. Su enfoque en el rendimiento y la productividad lo convierten en una herramienta atractiva para proyectos de diversos tamaños y complejidades.

Dejo link: https://github.com/zeromicro/go-zero