go version: go version go1.14 linux/amd64
go.mod
module [redacted]
go 1.14
require ( v1.4.0-rc.2 v1.27.1 v1.20.0 // indirect
)I am running the following command:
protoc -I ./src/pbdefs/protos/ --go-grpc_out=. src/pbdefs/protos/*.prototo generate my GRPC output files from .proto files, with I am getting an error
protoc-gen-go-grpc: program not found or is not executable
Please specify a program using absolute path or make sure the program is available in your PATH system variable
--go-grpc_out: protoc-gen-go-grpc: Plugin failed with status code 1.14 Answers
the missing plugin has been implemented at .
command below should fix it
go install The Golang Protobuf has released a new version of Go protocol buffers which they are calling it as the APIv2.
Because APIv2 is not backwards compatible with APIv1, therefore we will need to adapt all our Golang code for the new API.
You can learn more about the new API here and here
Migration steps:
In order to run the new code generation will be necessary to install the following gRPC gen plugins:
go get -u
go install
go get -u
go install Then use the following command to generate the code.
# generate the messages protoc --go_out="$GO_GEN_PATH" -I "$dependecies" "$proto" # generate the services protoc --go-grpc_out="$GO_GEN_PATH" -I "$dependecies" "$proto"If you haven't done, so you need to install the protoc-gen-go plugin like so:
go get this will install the plugin (if your GOPATH is ${HOME}/go) to:
${HOME}/go/bin/protoc-gen-goThen when running protoc, either update your path, or set it dynamically like so:
PATH="${PATH}:${HOME}/go/bin" protoc ...OK, just found out, as per
The v1.20
protoc-gen-godoes not support generating gRPC service definitions. In the future, gRPC service generation will be supported by a new protoc-gen-go-grpc plugin provided by the Go gRPC project.The version of protoc-gen-go continues to support gRPC and will continue to do so for the foreseeable future.
EDIT 29/05/2020:
Following an update from @Mark in the comments, according to the Tracking issue on github, protoc-gen-go-grpc has now been merged. However, according to the same issue:
4Even with this merged, it is unreleased (v0.0) and subject to change. We do plan to add a requirement that the Unimplemented service implementation be included in all registered services, with an escape hatch in the form of a command-line arg as suggested by @neild.
Update your PATH so that the protoc compiler can find the plugins:export PATH="$PATH:$(go env GOPATH)/bin"
Share my useful bash command here:
go get -u
go install
go get -u
go install
protoc --proto_path=./proto ./proto/*.proto --plugin=$(go env GOPATH)/bin/protoc-gen-go-grpc --go-grpc_out=./pb
protoc --proto_path=./proto ./proto/*.proto --plugin=$(go env GOPATH)/bin/protoc-gen-go --go_out=./pbFor all who aren't much into the topic (like me) and still have trouble to figure out a working solution, here's a step-by-step approach:
apt install protobuf-compilerinstalls the compiler underapt install protobuf-compiler, available viaprotocfrom then.- Install the old go generator plugin to be used by
protoc:go get -uandgo install. Also, make sure that the installed plugin can be found in$PATHor add it withexport PATH=$PATH:$(go env GOPATH)/binif needed. - To tell that plugin not only to generate the protobuf message type information but also the grcp methods, use a command like
protoc --go_out=plugins=grpc:my/relative/output/path ./my_file.proto.
Looks kinda trivial once you've figured that out, but it's quite hard to figure that out if you aren't into that topic and only have scarce information about how the go files generator generator and the grcp extension are supposed to work together.
2Please check the Go Environment variables by running the Go env command on the Terminal and make sure that the following values are set.
GOBIN=some folder location
GOPATH= some folder location
If these are looking good try installing the go plugin
go get -u or run the following on the terminal
go install I was searching for a good answer and finally, it worked for me:
protoc --go-grpc_out=. file_path/file_name*.proto I was able to solve a problem in 2022 by finding an answer in a GitHub issue
As @neild suggested, I added both GOPATH and GOROOT to my PATH environment variable by using the command
'export PATH=$PATH:$HOME/go/bin' for GOPATH
'export PATH=$PATH:/usr/local/go/bin' for GOROOT
and it works for me
i solve using this command :
- protoc calculator/calculatorpb/calculator.proto --go-grpc_out=.
- protoc -I=. --go_out=. calculator/calculatorpb/calculator.proto
to generate calculator_pb.go and calculator_grpc.go
syntax = "proto3";
package calculator;
option go_package = "calculator/calculatorpb";
message SumRequest { int32 first_number = 1; int32 second_number = 2;
}
message SumResponse { int32 sum_result =1 ;
}
service CalculatorService{ rpc Sum(SumRequest) returns(SumResponse) {}
}I had to install all these:
go install \ \ \ \ Use go get to download the following packages:
$ go get
$ go get
$ go get This installs the protoc generator plugins we need to generate the stubs. Make sure to add $GOPATH/bin to your $PATH so that executables installed via go get are available on your $PATH.
Here's an example of what a protoc command might look like to generate Go stubs, assuming that you're at the root of your repository and you have your proto files in a directory called proto:
$ protoc -I ./proto \ --go_out ./proto --go_opt paths=source_relative \ --go-grpc_out ./proto --go-grpc_opt paths=source_relative \ ./proto/helloworld/hello_world.protoWe use the go and go-grpc plugins to generate Go types and gRPC service definitions. We're outputting the generated files relative to the proto folder, and we're using the paths=source_relative option, which means that the generated files will appear in the same directory as the source .proto file.
You should check out the tutorial series on gRPC-Gateway, i.e., . Also, you can refer to my simple hello world program, which uses gRPC-Gateway, i.e., .
You can also use to install all protoc-related dependencies (including protoc-gen-go-grpc) with one click and for version control.
