Golang GRPC
Co to jest GRPC?
GRPC to wysokowydajny zdalny framework procedury, który pozwala programistom łączyć usługi między systemami. Korzystając z GRPC, aplikacje klienckie i serwerowe mogą bezbłędnie komunikować się.
Mówiąc najprościej, GRPC umożliwia aplikacji klienckiej dostępu i używania metod w aplikacji serwerowej (nawet w zdalnych maszynach), jakby została zdefiniowana w tej samej aplikacji. Jest to główny element składowy dla mikrousług.
Wymagania
Aby podążać za tym samouczkiem, musisz mieć:
- Najnowsza wersja kompilatora Go.
- Protocol Buffer Compiller (Protoc) wersja 3
- Wtyczki Go do pracy z buforami protokołu.
Aby zainstalować kompilator buforu protokołu, uruchom polecenie podane poniżej:
Zainstaluj Google.Golang.org/protOBUF/cmd/protoc-gen-go@najnowsze
Zainstaluj Google.Golang.org/grpc/cmd/protoc-gen-go-grpc@najnowszy
Następnym krokiem jest aktualizacja ścieżki, abyś mógł użyć poleceń Protoc:
Eksport ścieżka = "$ ścieżka: $ (Go env gopath)/bin"
Golang GRPC Server
W tym samouczku zbudujemy prosty serwer GRPC, który odbiera wiadomość wysłaną przez klienta i odzwierciedla ją.
Zacznij od utworzenia działającego katalogu:
Mkdir GRPC-TUT
CD GRPC-TUT
Następnie utwórz serwer.Plik Go, który pomieści kod dla serwera GRPC:
Serwer dotykowy.Iść
Otwórz plik za pomocą edytora tekstu i dodaj następujące wiersze:
Pakiet Main
import (
"dziennik"
"internet"
)
W poprzednim kodzie importujemy pakiety dziennika i netto, co pozwoli nam rejestrować błędy i ustanowienie słuchacza za pomocą pakietu netto.
Następnie skonfigurujemy główną funkcję i utworzymy słuchacz w porcie 9001/TCP:
func main ()
słuchacz, err: = net.Słuchaj („TCP”, „: 9001”)
Jeśli err != zero
dziennik.Fatalny (err)
Następnym krokiem jest zaimportowanie pakietu GRPC dla programu Go. To pozwoli nam skonfigurować serwer GRPC i punkty końcowe, które chcemy obsłużyć przed podłączeniem go z słuchaczem na TCP.
Importuj „Google.Golang.org/grpc "
Z powrotem w głównej funkcji możemy utworzyć serwer GRPC, jak pokazano w następującym kodzie:
grpserver: = grpc.Newserver ()
Jeśli err: = grpserver.Serve (słuchacz); błądzić != zero
dziennik.Fatalny (err)
W poprzednim kodzie tworzymy serwer GRPC przy użyciu metody Newserver (. Następnie obsługujemy serwer nad słuchaczem TCP, który stworzyliśmy wcześniej.
I dzięki temu mamy serwer GRPC. Jednak to niewiele robi. Możemy to przedłużyć, tworząc prostą aplikację ECHO.
Aplikacja odbędzie wiadomość od klienta i zwróci tę samą wiadomość do klienta.
Plik proto echo
Aby skonfigurować naszą aplikację ECHO, będziemy musieli utworzyć .plik proto. Plik Proto będzie utrzymywał definicje aplikacji.
dotyk echo.Proto
Pierwszym wpisem w pliku Proto będzie deklaracja pakietu. Zapobiega to zderzeniom nazwy w innych aplikacjach.
Syntax = "proto3";
Echo pakietu;
opcja go_package = "./Echo";
Możesz zmienić nazwę, aby odzwierciedlić nazwę pakietu.
Po otrzymaniu deklaracji pakietu musimy dodać definicje wiadomości. To określa kontener lub strukturę wiadomości do odbierania od klientów:
Wiadomość wiadomości
korpus strun = 1;
Następnie musimy zdefiniować usługę. W naszym przykładzie nazywamy usługę jako echoservice, jak pokazano:
Service Echoservice
RPC Echo (wiadomość) zwraca (wiadomość)
Usługa określa metodę, którą zadzwoni klient GRPC. Metoda po prostu bierze wiadomość i zwraca wiadomość. To tworzy aplikację ECHO.
Kompilowanie buforów protokołu
Teraz mamy Proto Definiowanie naszej aplikacji. Następnie musimy wygenerować klasy, których użyjemy do odczytu i zapisu danych za pomocą języka programowania Go.
Możemy to zrobić za pomocą kompilatora buforu protokołu:
Protoc -Go_Out =./echo --go GRPC_OUT =./echo --go-grpc_opt = wymaga_unimplemented_servers = false echo.Proto
Poprzednie polecenia powinny wygenerować kod GO wymagany do zarejestrowania się i wywołania serwera GRPC.
Następnym krokiem jest zdefiniowanie RPC dla metody echo. Możemy to zrobić, tworząc plik GO w katalogu echo jako:
dotyk echo.Iść
W pliku dodaj kod, jak pokazano:
Echo pakietu
import (
„FMT”
„Golang.org/x/net/context ”// Uzyskaj kontekst żądania
)
Wpisz Server Struct
FUNC (S *Server) Echo (kontekst CTX.Kontekst, komunikat *komunikat) ( *komunikat, błąd)
fmt.Printf („Otrzymano wiadomość: %s”, wiadomość.Ciało)
powrót i wiadomość body: „Cześć z powrotem!", zero
Następnym krokiem jest zaimportowanie kodu wewnątrz pakietu ECHO. Wróć do serwera.Go Plik i dodaj następującą klauzulę importu:
importować „GRPC/ECHO”
Będziesz musiał zainicjować menedżera modułu Go do swojego projektu.
W głównym pliku serwera dodaj następujące wiersze, aby utworzyć nowy serwer czat i zarejestruj go:
S: = Echo.Serwer
Echo.ReagerEchoserviceserver (GRPSERVER, & S)
I dzięki temu mamy kod dla serwera GRPC na uboczu.
Klient GRPC
Następnym krokiem jest zbudowanie klienta, który może wchodzić w interakcje z serwerem GRPC. Zacznij od utworzenia klienta pliku.Idź do głównego katalogu.
dotykać ./klient.Iść
Zacznijmy od naszego importu. Do tego będziemy potrzebować pakietów dziennika, kontekstu, echa i grpc
import (
"dziennik"
„Golang.org/x/net/kontekst "
"Google.Golang.org/grpc "
„GRPC/ECHO”
)
Następnie zacznijmy od głównej funkcji:
func main ()
// wskaźnik do grpc conn
var conn *grpc.ClientConn
// Połącz się z serwerem GRPC (niepewne połączenie)
conn, err: = grpc.Wybór („: 9001”, GRPC.Withsecure ())
Jeśli err != zero
dziennik.Fatalny (err)
// Zamknij Conn
Defer Conn.Zamknąć()
// Echo Client Service
e: = echo.NeweChoserviceClient (Conn)
// Ciało wiadomości
Wiadomość: = echo.Wiadomość
Ciało: „Cześć”,
RESC, err: = e.Echo (kontekst.Tło () i wiadomość)
Jeśli err != zero
dziennik.Fatalny (err)
fmt.Printf („%s”, odpowiednio.Ciało)
Poprzedni kod implementuje klienta GRPC, który wysyła wiadomość „Cześć” i odzyskuje „cześć” z serwera.
Testowanie
Po zakończeniu uruchom serwer.Idź i klient.Iść. Jeśli się powiedzie, serwer powinien odpowiedzieć „cześć”, jak pokazano poniżej:
Z powodzeniem zbudowałeś serwer GRPC i klient w Go.
Wniosek
Ten przewodnik służy jako absolutna podstawowa do wdrażania GRPC w Go. Jeśli jesteś nowy w GRPC i Protobufs, uchwycenie implementacji może zająć trochę czasu. Jednak przy kilku praktykach i wdrożeniu będziesz w stanie budować złożone usługi GRPC. Mamy nadzieję, że ten artykuł jest pomocny. Sprawdź inne artykuły Linux, aby uzyskać więcej wskazówek i samouczków.