Halo, Habr! Saya mempersembahkan untuk Anda terjemahan artikel
“Go, gRPC and Docker” oleh Mat Evans.
Ada banyak artikel tentang berbagi Go dan Docker. Membuat wadah yang dapat berinteraksi dengan pelanggan dan di antara mereka sendiri sangat mudah. Berikut ini adalah contoh kecil bagaimana ini dilakukan pada tingkat dasar.
Apa yang kita buat?
Kami akan membuat klien dan server yang sangat sederhana, berinteraksi satu sama lain menggunakan
gRPC . Server akan berlokasi di dalam wadah
Docker sehingga dapat dengan mudah digunakan.
Misalkan kita membutuhkan layanan yang menerima string dari klien dan mengembalikan string dengan urutan karakter terbalik. Misalnya, kirim "kucing" dan dapatkan "arus" sebagai respons.
file .proto
.proto- file menjelaskan operasi apa yang akan dilakukan layanan kami dan data apa yang akan dipertukarkan. Buat folder
proto di proyek, dan file
reverse.proto di dalamnya
syntax = "proto3"; package reverse; service Reverse { rpc Do(Request) returns (Response) {} } message Request { string message = 1; } message Response { string message = 1; }
Fungsi yang disebut jarak jauh di server dan mengembalikan data ke klien ditandai sebagai
rpc . Struktur data yang digunakan untuk bertukar informasi antara node yang berinteraksi ditandai sebagai
pesan . Setiap bidang pesan harus diberi nomor urut. Dalam hal ini, fungsi kami menerima pesan dari jenis
Permintaan dari klien dan mengembalikan pesan dari jenis
Respons .
Setelah kami membuat file
.proto , perlu untuk mendapatkan file
.go dari layanan kami. Untuk melakukan ini, jalankan perintah konsol berikut di folder
proto :
$ protoc -I . reverse.proto --go_out=plugins=grpc:.
Tentu saja, pertama Anda perlu
membangun gRPC .
Menjalankan perintah di atas akan membuat file
.go baru yang berisi metode untuk membuat klien, server, dan pesan yang mereka tukarkan. Jika kita memanggil
godoc , kita akan melihat yang berikut:
$ godoc . PACKAGE DOCUMENTATION package reverse import "." Package reverse is a generated protocol buffer package. It is generated from these files: reverse.proto It has these top-level messages: Request Response ....
Pelanggan
Alangkah baiknya jika klien kami bekerja seperti ini:
reverse "this is a test" tset a si siht
Berikut adalah kode yang membuat klien
gRPC menggunakan struktur data yang dihasilkan dari file
.proto :
package main import ( "context" "fmt" "os" pb "github.com/matzhouse/go-grpc/proto" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" ) func main() { opts := []grpc.DialOption{ grpc.WithInsecure(), } args := os.Args conn, err := grpc.Dial("127.0.0.1:5300", opts...) if err != nil { grpclog.Fatalf("fail to dial: %v", err) } defer conn.Close() client := pb.NewReverseClient(conn) request := &pb.Request{ Message: args[1], } response, err := client.Do(context.Background(), request) if err != nil { grpclog.Fatalf("fail to dial: %v", err) } fmt.Println(response.Message) }
Server
Server akan menggunakan file
.go yang sama. Namun, itu hanya mendefinisikan antarmuka server, tetapi kita harus mengimplementasikan logika kita sendiri:
package main import ( "net" pb "github.com/matzhouse/go-grpc/proto" "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" ) func main() { listener, err := net.Listen("tcp", ":5300") if err != nil { grpclog.Fatalf("failed to listen: %v", err) } opts := []grpc.ServerOption{} grpcServer := grpc.NewServer(opts...) pb.RegisterReverseServer(grpcServer, &server{}) grpcServer.Serve(listener) } type server struct{} func (s *server) Do(c context.Context, request *pb.Request) (response *pb.Response, err error) { n := 0
Docker
Saya berasumsi bahwa Anda tahu apa itu
Docker dan untuk apa
Docker . Inilah
Dockerfile kami:
FROM golang:1.12 ADD . /go/src/github.com/matzhouse/go-grpc/server RUN go install github.com/matzhouse/go-grpc/server ENTRYPOINT ["/go/bin/server"] EXPOSE 5300
Kode perakitan untuk gambar
Docker ditulis di sini. Kami akan menganalisanya baris demi baris.
FROM golang:1.12
Perintah ini berarti bahwa kita ingin membuat gambar aplikasi kita berdasarkan gambar yang dibuat sebelumnya, yaitu
golang . Ini adalah gambar
Docker dengan lingkungan yang sudah dikonfigurasi untuk membangun dan menjalankan program yang ditulis dalam
Go .
ADD . /go/src/github.com/matzhouse/go-grpc/server
Perintah ini menyalin kode sumber aplikasi kita ke dalam
wadah GOPATH / src .
RUN go install github.com/matzhouse/go-grpc/server
Perintah ini mengumpulkan aplikasi kita dari sumber yang disalin ke wadah dan memasangnya di
folder wadah
GOPATH / bin .
ENTRYPOINT ["/go/bin/server"]
Perintah ini mengkonfigurasi wadah untuk berfungsi sebagai program yang dapat dieksekusi. Di dalamnya, kami menunjukkan jalur ke aplikasi yang dapat dieksekusi dan, jika perlu, argumen baris perintah.
EXPOSE 5300
Dengan perintah ini, kami memberi tahu kontainer port mana yang harus diakses dari luar.
Server mulai
Kita perlu menjalankan wadah dengan aplikasi server kami.
Pertama, Anda perlu membangun gambar berdasarkan instruksi dari
Dockerfile :
$ sudo docker build -t matzhouse/grpc-server . Sending build context to Docker daemon 31.76 MB Step 1/5 : FROM golang ---> a0c61f0b0796 Step 2/5 : ADD . /go/src/github.com/matzhouse/go-grpc ---> 9508be6501c1 Removing intermediate container 94dc6e3a9a20 Step 3/5 : RUN go install github.com/matzhouse/go-grpc/server ---> Running in f3e0b993a420 ---> f7a0370b7f7d Removing intermediate container f3e0b993a420 Step 4/5 : ENTRYPOINT /go/bin/server ---> Running in 9c9619e45df4 ---> fb34dfe1c0ea Removing intermediate container 9c9619e45df4 Step 5/5 : EXPOSE 5300 ---> Running in 0403390af135 ---> 008e09b9aebd Removing intermediate container 0403390af135 Successfully built 008e09b9aebd
Sekarang kita dapat melihat gambar ini dalam daftar:
$ docker images REPOSITORY TAG IMAGE ID ... matzhouse/grpc-server latest 008e09b9aebd ...
Hebat! Kami memiliki gambar aplikasi server kami, yang dengannya Anda dapat meluncurkan wadahnya menggunakan perintah berikut:
$ docker run -it -p 5300:5300 matzhouse/grpc-server
Dalam hal ini, yang disebut
penerusan porta . Perhatikan bahwa untuk itu kita membutuhkan pernyataan
EXPOSE dan argumen
-p .
Peluncuran klien
Kontainerisasi klien tidak akan memberikan keuntungan besar, jadi mari kita mulai dengan cara biasa:
$ go build -o reverse $ ./reverse "this is a test" tset a si siht
Terima kasih sudah membaca!