How to deploy golang grpc

In recent years, the golang language has been favored by more and more developers. Its lightweight and high-concurrency features are widely used in the background services of some large enterprises. With the popularity of microservices and cloud native technology, golang is increasingly used in the server field, and golang's rpc framework grpc has also been widely used.

This article mainly introduces the deployment of grpc. Before deployment, you need to understand the basic concepts of golang and grpc.

1. Basic concepts of golang

Golang is a statically typed, compiled, and concurrent programming language, which was born from Google. There are some special concepts in golang language that need to be understood.

1. Goroutine: lightweight thread in golang is also the main means to achieve high concurrency.
2. Channel: A special data type in golang, used for communication between goroutines.
3. select: keyword used for multiplexing channels in golang.
4. defer: keyword used to delay the execution of functions in golang.
5. interface: A way to define behavior in golang.

2. Basic concepts of grpc

grpc is a high-performance, open source and general RPC framework, developed and open sourced by Google. grpc supports multiple languages, including golang, C, Java, etc. The characteristics of grpc are:

1. Supports multiple serialization protocols, including protobuf and json, etc.
2. Based on the http2 protocol, it supports advanced features such as bidirectional streaming, flow control, and header compression.
3. Supports custom authentication, load balancing and other extensions.

3. grpc deployment

After having the basic concepts, let’s introduce the deployment of grpc.

1. Write grpc server code

Suppose we want to write a simple grpc server program, the code is as follows:

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/your/proto"
)

const (
    port = ":50051"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.Name)
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

2. Write grpc Client code

Suppose we want to write a simple grpc client program, the code is as follows:

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "path/to/your/proto"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

3. Compile and generate binary files

The compilation command is as follows:

$ go build -o greeter_server ./server/main.go
$ go build -o greeter_client ./client/main.go

4. Run grpc server program

$ ./greeter_server

After running, you will see the following output:

2021/05/07 10:37:30 Listening on :50051

5. Run grpc client After running the terminal program

$ ./greeter_client

, you will see the following output:

2021/05/07 10:38:28 Greeting: Hello world

Among them, world is the default parameter, and other parameters can also be passed in, such as:

$ ./greeter_client Tim

After running, you will see the following output:

2021/05/07 10:39:22 Greeting: Hello Tim

4. Summary

This article mainly introduces the deployment of grpc, including writing grpc server program, writing grpc client program, and compiling and generating binary files. and run grpc server and client programs. If you want to learn more about golang and grpc, you can refer to official documents and other related materials.

The above is the detailed content of How to deploy golang grpc. For more information, please follow other related articles on the PHP Chinese website!