Golang Grpc
¿Qué es GRPC??
GRPC es un marco de llamadas de procedimiento remoto de alto rendimiento que permite a los desarrolladores conectar los servicios en todos los sistemas. Usando GRPC, las aplicaciones de cliente y servidor pueden comunicarse sin problemas.
En pocas palabras, GRPC permite que una aplicación cliente acceda y use métodos en una aplicación de servidor (incluso en máquinas remotas) como si estuviera definida en la misma aplicación. Es un componente importante para los microservicios.
Requisitos
Para seguir junto con este tutorial, deberá tener:
- La última versión del compilador GO.
- Compilador de búfer de protocolo (Protocas) Versión 3
- Vaya a los complementos para trabajar con buffers de protocolo.
Para instalar el compilador de búfer de protocolo, ejecute el comando como se proporciona a continuación:
Ir a instalar Google.golang.org/protoBuf/cmd/protoc-gener-go@Último
Ir a instalar Google.golang.org/grpc/cmd/protoc-gen-go-Grpc@Último
El siguiente paso es actualizar su ruta para que pueda usar los comandos de protocas:
Path de exportación = "$ Path: $ (Go Env Gopath)/Bin"
Servidor Golang Grpc
Para este tutorial, construiremos un servidor GRPC simple que tome el mensaje enviado por un cliente y lo haga eco.
Comience creando un directorio de trabajo:
mkdir grpc-tut
CD GRPC-TUT
A continuación, cree un servidor.GO FILE que mantendrá el código para el servidor GRPC:
Servidor táctil.ir
Abra el archivo con su editor de texto y agregue las siguientes líneas:
paquete principal
importar (
"registro"
"neto"
)
En el código anterior, importamos los paquetes de registro y la red, lo que nos permitirá registrar errores y establecer un oyente utilizando el paquete neto.
A continuación, configuraremos la función principal y crearemos un oyente en el puerto 9001/TCP:
func Main ()
oyente, err: = net.Escuchar ("tcp", ": 9001")
Si err != nulo
registro.Fatal (err)
El siguiente paso es importar el paquete GRPC para el programa GO. Esto nos permitirá configurar un servidor GRPC y los puntos finales que deseamos servir antes de conectarlo con el oyente en TCP.
importar "Google.golang.org/Grpc "
De vuelta en la función principal, podemos crear un servidor GRPC como se muestra en el siguiente código:
GrpServer: = GRPC.Newserver ()
Si err: = GrpServer.Servir (oyente); errar != nulo
registro.Fatal (err)
Creamos un servidor GRPC utilizando el método Newserver () en el código anterior. Luego servimos al servidor a través del oyente TCP que creamos anteriormente.
Y con eso, tenemos un servidor GRPC. Sin embargo, no hace mucho. Podemos extender esto creando una aplicación de eco simple.
La aplicación recibirá el mensaje del cliente y le devolverá el mismo mensaje al cliente.
Echo proto archivo
Para configurar nuestra aplicación Echo, necesitaremos crear un .archivo proto. El archivo Proto contendrá las definiciones para la aplicación.
toque el eco.proto
La primera entrada en el archivo Proto será la declaración del paquete. Esto evita colisiones de nombres en otras aplicaciones.
sintaxis = "proto3";
paquete eco;
opción go_package = "./eco";
Puede cambiar el nombre para reflejar el nombre de su paquete.
Una vez que tenemos la declaración del paquete, necesitamos agregar definiciones de mensajes. Esto define un contenedor o estructura del mensaje para recibir de los clientes:
mensaje Mensaje
cuerpo de cadena = 1;
A continuación, necesitamos definir el servicio. En nuestro ejemplo, llamamos al servicio como Echoservice como se muestra:
Ecoservice de servicio
rpc echo (mensaje) devuelve (mensaje)
El servicio define un método que llamará un cliente GRPC. El método simplemente toma el mensaje y devuelve el mensaje. Esto crea una aplicación de eco.
Compilación de los amortiguadores de protocolo
Ahora tenemos el Proto Defining para nuestra aplicación. A continuación, necesitamos generar las clases que usaremos para leer y escribir datos utilizando el lenguaje de programación GO.
Podemos hacer esto utilizando el compilador de búfer de protocolo:
Protoc --go_out =./echo --go-grpc_out =./echo --Go-Grpc_opt = require_unimplemented_servers = false eco.proto
Los comandos anteriores deben generar el código GO requerido para registrarse y llamar al servidor GRPC.
El siguiente paso es definir el RPC para el método ECHO. Podemos hacer esto creando un archivo GO en el directorio ECHO como:
toque el eco.ir
En el archivo, agregue el código como se muestra:
Echo de paquete
importar (
"FMT"
"Golang.org/x/net/context "// obtener contexto de solicitud
)
Escriba la estructura del servidor
FUNC (S *servidor) echo (contexto CTX.Contexto, mensaje *mensaje) ( *mensaje, error)
fmt.Printf ("Mensaje recibido: %s", mensaje.Cuerpo)
Regreso y mensaje cuerpo: "Hola de regreso!", nil
El siguiente paso es importar el código dentro del paquete de eco. Vuelve al servidor.IR FILE y agregue la siguiente cláusula de importación:
Importar "GRPC/ECHO"
Deberá inicializar el administrador del módulo GO para su proyecto.
En el archivo del servidor principal, agregue las siguientes líneas para crear un nuevo servidor de chat y registrarlo:
s: = echo.Servidor
eco.RegistroChosServiceserver (Grpserver, & s)
Y con eso, tenemos el código para el servidor GRPC fuera del camino.
cliente de GRPC
El siguiente paso es construir un cliente que pueda interactuar con el servidor GRPC. Comience creando un cliente de archivo.ir al directorio principal.
tocar ./cliente.ir
Comencemos con nuestras importaciones. Para este, necesitaremos los paquetes de registro, contexto, eco y GRPC
importar (
"registro"
"Golang.org/x/net/context "
"Google.golang.org/Grpc "
"GRPC/ECHO"
)
A continuación, comencemos con la función principal:
func Main ()
// puntero a Grpc Conn
var conn *GRPC.ClientConn
// conectarse al servidor GRPC (conexión insegura)
Conn, err: = GRPC.Dial (": 9001", GRPC.WithinSecure ())
Si err != nulo
registro.Fatal (err)
// Cerrar conn
diferir a Conn.Cerca()
// Cliente de servicio de eco
E: = Echo.Newecoserviceclient (Conn)
// Cuerpo del mensaje
Mensaje: = Echo.Mensaje
Cuerpo: "Hola",
resp, err: = e.Echo (contexto.Fondo (), y mensaje)
Si err != nulo
registro.Fatal (err)
fmt.Printf ("%s", resp.Cuerpo)
El código anterior implementa un cliente GRPC, que envía el mensaje "Hola" y obtiene "HI Back" del servidor.
Pruebas
Una vez completado, ejecute el servidor.ir y cliente.ir. Si tiene éxito, el servidor debe responder con "HI Back" como se muestra a continuación:
Ha creado con éxito un servidor y cliente de GRPC en GO.
Conclusión
Esta guía sirve como un básico absoluto para implementar GRPC en GO. Si es nuevo en GRPC y ProTobufs, puede llevar tiempo comprender la implementación. Sin embargo, con algunas prácticas e implementación, estará en condiciones de crear servicios de GRPC complejos. Esperamos que hayas encontrado este artículo útil. Consulte otros artículos de Linux para obtener más consejos y tutoriales.