Chapter8. gRPC - Basic, Json to protobuf

[robert-min]

RPC(Remote Procedure Call)

• 원격 프로시저 콜 : 함수를 호출하는데, 함수가 애플리케이션 바이너리 안에 포함되지 않고 네트워크를 넘어 다른 서비스에 정의되어 사용되는 호출 방법
• 일반적인 RPC는 서버와 클라이언트 모두 Go 언어로 작성되어야하는 제약이 존재 -> 해당 문제 해결을 위해 RPC 함수에 대한 언어 중립적인 RPC 프레임워크 사용이 필요하며 그 중 대표적인 것이 gRPC

gRPC

• 언어 중립적인 RPC 프레임워크로 어떤 프로그래밍 언어든 사용하여 서버와 클라이언트 작성이 가능
• 효율적인 데이터 교환 포맷으로 protocol buff(protobuf)를 사용
  • protobuf의 데이터 포맷은 JSON과 달리 기계만 읽을 수 있지만, 프로토콜 버퍼 언어는 사람이 읽을 수 있음

[robert-min]

gRPC 서버 구축을 위한 프로토콜 버퍼 언어로 서비스 정의

• Users 라는 서비스에서 UserGetRequest 타입의 입력 메세지를 매겨변수로 받고
• UserGetReply 타입의 메시지를 반환
• gRPC에서 함수는 클라이언트와 서버 애플리케이션 간에 메시지를 주고받으며 통신할 수 있도록 반드시 입력 메시지를 매개변수로 받고 출력 메시지를 반환해야 함.

// ./service/users.proto
syntax = "proto3";

option go_package = "github.com/handson-go/chap8/user_service/service";

service Users {
    rpc GetUser (UserGetRequest) returns (UserGetReply) {}
}

message UserGetRequest {
    string email = 1;
    string id = 2;
}

message User {
    string id = 1;
    string first_name = 2;
    string last_name = 3;
    int32 age = 4;
}

message UserGetReply {
    User user = 1;
}

• 위의 파일과 동일 경로에서 아래 명령어 실행
  • --go_out, go-rpc_out 옵션은 생성된 magic glue(프로토콜 버퍼 정의, 서버와 클라이언트 어플리케이션 구현체, 네트워크 상 두 장비가 통신 가능한 형태의 포로토콜 버퍼 데이터 세가지를 묶어주는 역할)이 저장될 경로
  • --go_opt, --go-grpc_opt 옵션은 users.proto 파일 기준 상대 경로에 위치한 곳에 생성
• 위 명령어 실행하면 서비스의 프로토콜 버퍼 메시지 타입과 인터페이스에 해당하는 GO 언어 스텝 구현체인 users.pb.go, users_grpc.pd.go 파일이 생성

  protoc --go_out=. --go_opt=paths=source_relative \
  --go-grpc_out=. --go-grpc_opt=paths=source_relative \
  users.proto

[robert-min]

위에서 생성한 프로토콜 버퍼를 사용하는 서버 구축

• grpc 라이브러리 의존성 부여를 위해 해당 파일이 있는 경로에서 아래 명령어 실행

go get google.golang.org/grpc@v1.37.0

package main

import (
    "context"
    "errors"
    "log"
    "net"
    "os"
    "strings"

    users "github.com/handson-go/chap8/user_service/service"
    "google.golang.org/grpc"
)

type userService struct {
    users.UnimplementedUsersServer
}

func (s *userService) GetUser(ctx context.Context, in *users.UserGetRequest) (*users.UserGetReply, error) {
    log.Printf(
        "Received request for user with Email: %s Id: %s\n",
        in.Email,
        in.Id,
    )
    components := strings.Split(in.Email, "@")
    if len(components) != 2 {
        return nil, errors.New("invalid email address")
    }

    u := users.User{
        Id:        in.Id,
        FirstName: components[0],
        LastName:  components[1],
        Age:       36,
    }
    return &users.UserGetReply{User: &u}, nil
}

func registerServices(s *grpc.Server) {
    users.RegisterUsersServer(s, &userService{})
}

func startServer(s *grpc.Server, l net.Listener) error {
    return s.Serve(l)
}

func main() {
    listenAddr := os.Getenv("LISTEN_ADDR")
    if len(listenAddr) == 0 {
        listenAddr = ":50051"
    }

    lis, err := net.Listen("tcp", listenAddr)
    if err != nil {
        log.Fatal(err)
    }
    s := grpc.NewServer()
    registerServices(s)
    log.Fatal(startServer(s, lis))
}

• 서버 build 전 go mod 의존성 부여

// ./go.mod
replace github.com/handson-go/chap8/user_service/service => ../service

// sh
go mod tidy

[robert-min]

서버 테스트를 위한 Client 생성

• grpc.DialContext() 함수로 Connection 객체 생성 후 통신을 위해 getUserServiceClient 함수 작성

  
  package main

import ( "context" "fmt" "log" "os"

users "github.com/handson-go/chap8/user_service/service"
"google.golang.org/grpc"

)

// Set up Grpc Connection with Server func setupGrpcConn(addr string) (*grpc.ClientConn, error) { return grpc.DialContext( context.Background(), // 공백의 Context addr, // 연결할 서버의 주소 grpc.WithInsecure(), // 전송계층보안 사용하지 않고 서버와 통신을 수립하기 위해 사용 grpc.WithBlock(), // 함수가 반환되기 전 연결이 먼저 수립외더 연결 객체가 반환되도록 설정 ) }

func getUserServiceClient(conn *grpc.ClientConn) users.UsersClient { return users.NewUsersClient(conn) }

func getUser( client users.UsersClient, u users.UserGetRequest, ) (users.UserGetReply, error) { return client.GetUser(context.Background(), u) }

func main() { if len(os.Args) != 2 { log.Fatal( "Must specify a gRPC server address", ) } conn, err := setupGrpcConn(os.Args[1]) if err != nil { log.Fatal(err) } defer conn.Close()

c := getUserServiceClient(conn)

result, err := getUser(
    c,
    &users.UserGetRequest{Email: "kim@naver.com"},
)
if err != nil {
    log.Fatal(err)
}

fmt.Fprintf(
    os.Stdout, "User: %s %s \n",
    result.User.FirstName, result.User.LastName,
)

}

[robert-min]

Server test code

package main

import (
    "context"
    "log"
    "net"
    "testing"

    users "github.com/handson-go/chap8/user_service/service"
    "google.golang.org/grpc"
    "google.golang.org/grpc/test/bufconn"
)

// Start test GRPC server with real network listener
func startTestGrpcServer() (*grpc.Server, *bufconn.Listener) {
    l := bufconn.Listen(10)
    s := grpc.NewServer()
    registerServices(s)
    go func() {
        err := startServer(s, l)
        if err != nil {
            log.Fatal(err)
        }
    }()
    return s, l
}

func TestUserService(t *testing.T) {
    s, l := startTestGrpcServer()
    defer s.GracefulStop()

    // 다이얼러 생성
    bufconnDialer := func(ctx context.Context, add string) (net.Conn, error) {
        return l.Dial()
    }

    // 테스트서버 연결을 위한 클라이언트 생성
    client, err := grpc.DialContext(
        context.Background(),
        "",
        grpc.WithInsecure(),
        grpc.WithContextDialer(bufconnDialer), // 네트워크를 인메모리 연결로 구성
    )
    if err != nil {
        t.Fatal(err)
    }

    usersClient := users.NewUsersClient(client)
    resp, err := usersClient.GetUser(
        context.Background(),
        &users.UserGetRequest{
            Email: "kim@naver.com",
            Id:    "foo-bar",
        },
    )
    if err != nil {
        t.Fatal(err)
    }
    if resp.User.FirstName != "kim" {
        t.Errorf(
            "Expected FirstName to be : kim, Got : %s",
            resp.User.FirstName,
        )
    }
}

[robert-min]

Client test code

package main

import (
    "context"
    "log"
    "net"
    "testing"

    users "github.com/handson-go/chap8/user_service/service"
    "google.golang.org/grpc"
    "google.golang.org/grpc/test/bufconn"
)

type dummyUserService struct {
    users.UnimplementedUsersServer
}

func (s *dummyUserService) GetUser(ctx context.Context, in *users.UserGetRequest) (*users.UserGetReply, error) {
    u := users.User{
        Id:        "user-123-a",
        FirstName: "kim",
        LastName:  "min",
        Age:       36,
    }
    return &users.UserGetReply{User: &u}, nil
}

func startTestGrpcServer() (*grpc.Server, *bufconn.Listener) {
    l := bufconn.Listen(10)
    s := grpc.NewServer()
    users.RegisterUsersServer(s, &dummyUserService{})
    go func() {
        err := s.Serve(l)
        if err != nil {
            log.Fatal(err)
        }
    }()
    return s, l
}

func TestGetUser(t *testing.T) {
    s, l := startTestGrpcServer()
    defer s.GracefulStop()

    // 다이얼러 생성
    bufconnDialer := func(ctx context.Context, add string) (net.Conn, error) {
        return l.Dial()
    }

    // 테스트서버 연결을 위한 클라이언트 생성
    conn, err := grpc.DialContext(
        context.Background(),
        "",
        grpc.WithInsecure(),
        grpc.WithContextDialer(bufconnDialer), // 네트워크를 인메모리 연결로 구성
    )
    if err != nil {
        t.Fatal(err)
    }

    c := getUserServiceClient(conn)
    result, err := getUser(
        c,
        &users.UserGetRequest{Email: "kim@min.com"},
    )
    if err != nil {
        t.Fatal(err)
    }

    if result.User.FirstName != "kim" || result.User.LastName != "min" {
        t.Fatalf(
            "Expected: kim doe, min: %s %s",
            result.User.FirstName,
            result.User.LastName,
        )
    }
}

[robert-min]

HTTP vs gRPC

• 공통점
  • 두 종류의 서버 애플리케이션 모두 네트워크 서버를 구성하고 네트워크 요청을 처리하기 위한 핸들러 함수를 가짐
• 차이점
  • HTTP는 임의의 핸들러 함수를 정의하고 임의의 경로에 핸들러 함수를 등록할 수 있음
  • gRPC는 프로토콜 버퍼 언어로 정의된 서비스 명세에 해당하는 함수에 대해 등록된 RPC 함수 호출만을 처리할 수 있음
  • HTTP는 클라이언틑 아무 HTTP 서버에나 요청을 보낼 수 있고, 잘못된 요청을 보냈을 때, 오류 응답을 받을 수 있음.
  • gRPC는 오직 프로토콜 버퍼 명세로 정의된 RPC 함수 호출하는 경우만 사용하며 클라이언트는 메시지를 서버로 전송하기 위해 반드시 RPC 서버에서 이해하는 형태를 알고 있어야 함

[robert-min]

json 포맷 문자열 프로토콜 버퍼으로 변환

• Marshal Unmarshal 함수 사용

[robert-min]

json 포맷 문자열 프로토콜 버퍼 객체로 언마셜링, 마셜링 코드

// 위 코드 동일

func createUserRequest(jsonQuery string) (*users.UserGetRequest, error) {
    u := users.UserGetRequest{}
    input := []byte(jsonQuery)
    return &u, protojson.Unmarshal(input, &u)
}

func getUserResponseJson(result *users.UserGetReply) ([]byte, error) {
    return protojson.Marshal(result)
}

func main() {
    if len(os.Args) != 3 {
        log.Fatal(
            "Must specify a gRPC server address and search query",
        )
    }
    serverAddr := os.Args[1]

    u, err := createUserRequest(os.Args[2])
    if err != nil {
        log.Fatalf("Bad user input : %v", err)
    }

    conn, err := setupGrpcConn(serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    c := getUserServiceClient(conn)

    result, err := getUser(
        c,
        u,
    )
    if err != nil {
        log.Fatal(err)
    }

    data, err := getUserResponseJson(result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Fprint(
        os.Stdout, string(data),
    )
}

[robert-min]

프로토콜 버퍼 메시지 주의사항

• 절대로 필드의 태그를 변경하면 안됨.
• 필드의 데이터 타입을 변경하려면 구버전의 데이터 타입과 신버전의 데이터 타입이 서로 호환 가능해야 함.
• 절대로 필드의 이름을 변경해서는 안됨.
• 완전히 동일한 순간에 클라이언트와 서버를 동시에 바꾸는 경우를 제외하고 서비스의 이름을 변경하면 기존의 클라이언트는 필연적으로 호환성이 깨지게 됨
• 함수의 이름을 변경할 수 없음.