fullstorydev / grpcurl Goto Github PK
View Code? Open in Web Editor NEWLike cURL, but for gRPC: Command-line tool for interacting with gRPC servers
License: MIT License
Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers
License: MIT License
Neither go get github.com/fullstorydev/grpcurl/cmd/grpcurl
nor make install
is working.
make install
go install ./...
# github.com/jhump/protoreflect/desc/protoparse
../../jhump/protoreflect/desc/protoparse/parser.go:391:52: undefined: descriptor.EnumDescriptorProto_EnumReservedRange
../../jhump/protoreflect/desc/protoparse/parser.go:452:52: undefined: descriptor.EnumDescriptorProto_EnumReservedRange
../../jhump/protoreflect/desc/protoparse/parser.go:788:7: ed.ReservedName undefined (type *descriptor.EnumDescriptorProto has no field or method ReservedName)
../../jhump/protoreflect/desc/protoparse/parser.go:791:7: ed.ReservedRange undefined (type *descriptor.EnumDescriptorProto has no field or method ReservedRange)
../../jhump/protoreflect/desc/protoparse/parser.go:798:60: undefined: descriptor.EnumDescriptorProto_EnumReservedRange
../../jhump/protoreflect/desc/protoparse/parser.go:799:9: undefined: descriptor.EnumDescriptorProto_EnumReservedRange
../../jhump/protoreflect/desc/protoparse/parser.go:1164:25: enum.GetReservedRange undefined (type *descriptor.EnumDescriptorProto has no field or method GetReservedRange)
../../jhump/protoreflect/desc/protoparse/parser.go:1645:32: ed.ReservedRange undefined (type *descriptor.EnumDescriptorProto has no field or method ReservedRange)
../../jhump/protoreflect/desc/protoparse/parser.go:1646:22: ed.ReservedRange undefined (type *descriptor.EnumDescriptorProto has no field or method ReservedRange)
../../jhump/protoreflect/desc/protoparse/parser.go:1660:22: ed.ReservedName undefined (type *descriptor.EnumDescriptorProto has no field or method ReservedName)
../../jhump/protoreflect/desc/protoparse/parser.go:1660:22: too many errors
make: *** [install] Error 2
I'm trying to deploy my grpc service behind traefik proxy, so localhost:9999 becomes localhost:80/api. Sadly I cannot do anything with grpcurl
because it complains when adress contains path as well. Is it wrong to run grpc in such a way?
╭─krever@wp-xps ~
╰─$ grpcurl localhost/api list
Failed to dial target host "localhost/api": dial tcp: address localhost/api: missing port in address
╭─krever@wp-xps ~
╰─$ grpcurl localhost:80/api list
Failed to dial target host "localhost:80/api": dial tcp: address tcp/80/api: unknown port
Hi @jhump. Thanks for this great project. I noticed that there is documentation for reflection of services - which I'm able to use without any problems - but there's no documentation / samples around reflection of service inputs and outputs. Is that at all possible? If so, does one go about it? I naively tried grpcurl describe <the value of InputType that the service description gave>
but this did not work.
Thanks!
I couldn't get the stdin streaming example working with a here string (<<<
).
Instead I found success using a here doc (<<
):
Here's what worked for me:
grpcurl -v -plaintext -d @ \
localhost:8080 pb.EventService/StreamPeople << EOF
{
"name": "Kevin"
}
{
"name": "Chen"
}
EOF
Hello there!
I would like to add the grpc status details
in the error output of the CLI, I simply want to display the response as google designed it, see here
Currently the CLI print the error like this: (cmd/grpcurl/grpcurl.go
)
if h.Status.Code() != codes.OK {
fmt.Fprintf(os.Stderr, "ERROR:\n Code: %s\n Message: %s\n",
h.Status.Code().String(), h.Status.Message())
exit(1)
}
I propose to add the details:
if h.Status.Code() != codes.OK {
fmt.Fprintf(os.Stderr, "ERROR:\n Code: %s\n Message: %s\n Details: %+v\n",
h.Status.Code().String(), h.Status.Message(), h.Status.Details())
exit(1)
}
I will be happy to do the PR, so what do you think?
P.S: I was wondering if we could add an option to output this in JSON too, since the CLI already outputs in JSON for OK responses.
Hi,
I'm using grpcurl as a library in a client CLI application. Since writing JSON lacks a bit of user friendliness, I would prefer to use the protobuf text format instead.
Compare:
grpcurl -d '{"fan": 0, "mode": "FAN_MODE_PERCENTAGE", "percentage": 50}' -plaintext 127.0.0.1:80 bmc.ManagementService.SetFan
with:
grpcurl -d 'fan: 0, mode: FAN_MODE_PERCENTAGE, percentage: 50' -plaintext 127.0.0.1:80 bmc.ManagementService.SetFan
or as it will be in the client I'm writing:
ubmcctl SetFan fan: 0, mode: FAN_MODE_PERCENTAGE, percentage: 50
Looking at the code I don't see any clear way of making this happen without breaking the interface, except for allowing JSON / Text format interchangeably. Which may be a feature, but could also create some confusion.
Thanks for your consideration
grpcurl version: 1.1.0
proto3 is used
Case:
enum Status {
ACTIVE = 0;
INACTIVE = 1;
}
if Status is INACTIVE, return:
{
"status": "INACTIVE"
}
if Status is ACTIVE, return: {}
which should return
{
"status": "ACTIVE"
}
Thanks for this great tool!
when i try to send nested json data as a string by grpcurl, it throws out the following error:
error getting request data: bad input: expecting string ; instead got {
my data schema:
{
"origin": "test.jpg",
"annotations": [
{
"title": "",
"description": "",
"view": {
"y": 200,
"x": 200
}
}
],
"findings": [
"finding_1",
"finding_2",
"finding_3"
],
"image": "test_test.jpg"
}
sine the json data is too long for typing.. i use a make file to read in and pass it to grpcurl as the following:
FILE := test.json
json := $(shell cat ${FILE})
data := '{"appid": "test_app", "jsonData": ${json}, "others": ""}'
grpcurl_test:
grpcurl -insecure -d ${data} \
localhost:10000 Service/method
Could you please give me some hints about this?
Thanks.
Error:
$ go get github.com/fullstorydev/grpcurl
go get: warning: modules disabled by GO111MODULE=auto in GOPATH/src;
ignoring ../../go.mod;
see 'go help modules'
# github.com/jhump/protoreflect/dynamic/grpcdynamic
github.com/jhump/protoreflect/dynamic/grpcdynamic/stub.go:35:5: cannot use (*grpc.ClientConn)(nil) (type *grpc.ClientConn) as type Channel in assignment:
*grpc.ClientConn does not implement Channel (missing Invoke method)
$ go install github.com/fullstorydev/grpcurl/cmd/grpcurl
# github.com/jhump/protoreflect/dynamic/grpcdynamic
github.com/jhump/protoreflect/dynamic/grpcdynamic/stub.go:35:5: cannot use (*grpc.ClientConn)(nil) (type *grpc.ClientConn) as type Channel in assignment:
*grpc.ClientConn does not implement Channel (missing Invoke method)
Probably caused by newer(and breaking changes) dependency
Using a github issue when I have no issue to report!
Great tool, this helped me.
Just saying thanks.
As of d86529b, I tried to setup the project to reproduce a bug, but when running make install
it says
$ make install
go install -ldflags '-X "main.version=dev build v1.0.0-15-gd86529b-dirty"' ./...
go: finding github.com/jhump/protoreflect/dynamic/grpcdynamic latest
go: finding github.com/jhump/protoreflect/grpcreflect latest
go: finding github.com/jhump/protoreflect/internal latest
go: finding github.com/jhump/protoreflect/dynamic latest
invoke.go:15:2: unknown import path "github.com/jhump/protoreflect/dynamic/grpcdynamic": cannot find module providing package github.com/jhump/protoreflect/dynamic/grpcdynamic
desc_source.go:14:2: unknown import path "github.com/jhump/protoreflect/grpcreflect": cannot find module providing package github.com/jhump/protoreflect/grpcreflect
../../go/pkg/mod/github.com/jhump/[email protected]/desc/descriptor.go:18:2: unknown import path "github.com/jhump/protoreflect/internal": cannot find module providing package github.com/jhump/protoreflect/internal
make: *** [Makefile:21: install] Error 1
Sure would be nice if you built pre-built binaries for linux, mac, etc. in your releases (along with checksums). Most of the other tools in our pipeline do something like that...
If an Unary RPC is called and the output contains only default values (explicitly set on the response), the values don't show upless I set -emit-defaults
. This is somewhat surprising behaviour because I would expect that option only to have any effect if the values on the response are not set. However if they are set and just happen to match the defaults, grpcurl is not printing the response unless I set -emit-defaults
.
If I do the same call with a client library (such as the Node.js gRPC library), the values (the number 0 in this case) are there.
Related to #52: now that there is a grpcurl
recipe in Homebrew, I think we need to look into ways to automate releases so that the brew artifacts are updated also. Currently, the release process results in a tag in the repo and artifacts uploaded to GitHub.
as of this date (and go version go1.12.1 darwin/amd64)
$ go get github.com/fullstorydev/grpcurl
results in
# github.com/fullstorydev/grpcurl
../GitHub/go/src/github.com/fullstorydev/grpcurl/grpcurl.go:600:4: undefined: grpc.WithContextDialer
This is not the general standard for Protobuf JSON https://developers.google.com/protocol-buffers/docs/proto3#json, jsonpb should be used instead. This will affect inputs such as Well-Known Types.
This can be accomplished via protoreflect, however jsonpb does not have a json.Decoder
equivalent, you'll have to have semantics to denote the splitting of messages (perhaps just a newline). https://godoc.org/github.com/fullstorydev/grpcurl#RequestMessageSupplier should also return []byte
instead of json.RawMessage
to not bind the API to the encoding/json
package.
Hello !
I looked over the internet but so far I haven't seen an error like this elsewhere.
I get this when grpcurl
tries to decode the response of my server.
ERROR:
Code: Internal
Message: grpc: failed to unmarshal the received message bad input; field api.Foo.UpdateTS requires length-delimited wire type
This field in question is of type google.protobuf.Timestamp.
Is there any chance you know what is going on and how I can fix this?
Cheers!
I have a use case where I'd the headers to be able to be read from stdin, in particular I'm passing credentials through the headers and I don't want the credentials to show up as command line parameters which exposes the credentials.
Would it be possible to allow the headers to be read from stdin like the request data? I could put in a PR if this is simple, would you accept it?
I was thinking of putting a switch like this for reading from stdin just like the request data: https://github.com/fullstorydev/grpcurl/blob/master/cmd/grpcurl/grpcurl.go#L489
More of a suggestion. Seems like in most cases it would be nice to ignore these.
I have couple of gRPC services and they are hosted in different servers and have fronted them using a Nginx reverse proxy. I created a new service that only does server reflection for all the services even though they are hosted in different servers and proxied all the /grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo calls to this service.
Service A
com.example.grpc.PublicHelloService/sayHello
Service B
com.example.grpc.HelloService/sayHello
Service - server reflection for Service A and Service B
When I try to call remote method in Service A using grpcurl
grpcurl -d '{}' nginx-reverse-proxy:443 "com.example.grpc.PublicHelloService/sayHello"
I get an error saying
Failed to construct request parser and formatter for "json": error creating message resolver: Symbol not found: com.example.grpc.HelloService
Is there a way to ignore symbols the are not required for current call.
As grpcurl
is using standard flags
package, it's requires to pass flags before positional arguments.
It pretty difficult to "play around" with different commands. I would propose to use come well established CLI libraries for streamlining this process.
Here are one of the libraries that may work:
https://github.com/spf13/cobra/
https://github.com/alecthomas/kingpin
https://github.com/urfave/cli
The change could be done in a backward compatible way I believe.
I could work on a PR if this change would be desired.
Hi there, thanks for the time spended in this awesome tool, it helps me a lot to test my microservice architecture. :-)
It is possible to send binary data to the gRPC server?
Something like curl does.
Thank you for your time :-)
I have a very simple test setup with server reflection enabled - no proxies or multiple servers, just a single service exposing a few methods.
I can successfully list methods with:
grpcurl -plaintext localhost:50051 describe test.MyService.Login
test.MyService.Login is a method:
rpc Login ( .test.LoginRequest ) returns ( .test.LoginReply ) {
option (.google.api.http) = { post:"/login" };
}
As well as get info on the types:
grpcurl -msg-template -plaintext localhost:50051 describe test.LoginRequest
test.LoginRequest is a message:
message LoginRequest {
string email = 1;
string password = 2;
}
Message template:
{
"email": "",
"password": ""
}
But, if i try to call a method - it fails:
grpcurl -plaintext -d '{"email":"test", "password":"test"}' localhost:50051 test.MyService/Login
Failed to construct request parser and formatter for "json": error creating message resolver: Symbol not found: grpc.reflection.v1alpha.ServerReflection
Any ideas?
Worth mentioning is that Polyglot works with no issues.
(Thanks for this project!)
Assume a simple service like the one described in extended.proto, and libprotoc 3.5.1 installed.
I generate extended.protoset
:
$ protoc --proto_path=$GOPATH/src --descriptor_set_out=extended.protoset --include_imports $GOPATH/src/github.com/kchristidis/nested/lib/extended/extended.proto
Then, when invoking grpcurl
, I get:
$ grpcurl -protoset extended.protoset list
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x114de11]
goroutine 1 [running]:
github.com/golang/protobuf/protoc-gen-go/descriptor.(*FileDescriptorProto).GetName(...)
/Users/kchrist/Go/src/github.com/jhump/protoreflect/desc/descriptor.go:77
github.com/jhump/protoreflect/desc.CreateFileDescriptor(0xc4201982d0, 0xc42004b400, 0x2, 0x2, 0x2, 0xc42004b400, 0x1)
/Users/kchrist/Go/src/github.com/jhump/protoreflect/desc/descriptor.go:77 +0x1d1
github.com/fullstorydev/grpcurl.resolveFileDescriptor(0xc42017e2a0, 0xc42017e2d0, 0xc420018740, 0x39, 0xc420169380, 0x0, 0x0)
/Users/kchrist/Go/src/github.com/fullstorydev/grpcurl/grpcurl.go:110 +0x2c2
github.com/fullstorydev/grpcurl.DescriptorSourceFromFileDescriptorSet(0xc42015ba38, 0xc42004b3a0, 0x2, 0x2, 0xc42004b290)
/Users/kchrist/Go/src/github.com/fullstorydev/grpcurl/grpcurl.go:86 +0x1d1
github.com/fullstorydev/grpcurl.DescriptorSourceFromProtoSets(0xc42004b170, 0x1, 0x1, 0xc4200165d0, 0xc420059d80, 0x15219e4, 0x6)
/Users/kchrist/Go/src/github.com/fullstorydev/grpcurl/grpcurl.go:75 +0x505
main.main()
/Users/kchrist/Go/src/github.com/fullstorydev/grpcurl/cmd/grpcurl/grpcurl.go:230 +0x34c
What am I doing wrong?
grpcurl retries forever even after server sends GOAWAY frame
I tried something like this:
gcurl -plaintext localhost:50051 describe
from server with GODEBUG="http2debug=2"
:
2019/08/10 22:56:11 connection is idle
2019/08/10 22:56:11 http2: Framer 0xc0002d9880: wrote GOAWAY len=8 LastStreamID=0 ErrCode=NO_ERROR Debug=""
2019/08/10 22:56:11 h2c: attempting h2c with prior knowledge.
2019/08/10 22:56:11 http2: server connection from [::1]:44508 on 0xc0001f95f0
2019/08/10 22:56:11 http2: Framer 0xc0002d9b20: wrote SETTINGS len=24, settings: MAX_FRAME_SIZE=1048576, MAX_CONCURRENT_STREAMS=250, MAX_HEADER_LIST_SIZE=1048896, INITIAL_WINDOW_SIZE=1048576
2019/08/10 22:56:11 http2: server: client [::1]:44508 said hello
2019/08/10 22:56:11 http2: Framer 0xc0002d9b20: read SETTINGS len=0
2019/08/10 22:56:11 http2: server read frame SETTINGS len=0
2019/08/10 22:56:11 http2: Framer 0xc0002d9b20: wrote SETTINGS flags=ACK len=0
2019/08/10 22:56:11 http2: Framer 0xc0002d9b20: wrote WINDOW_UPDATE len=4 (conn) incr=983041
2019/08/10 22:56:11 http2: Framer 0xc0002d9b20: read SETTINGS flags=ACK len=0
2019/08/10 22:56:11 http2: server read frame SETTINGS flags=ACK len=0
2019/08/10 22:56:12 connection is idle
2019/08/10 22:56:12 http2: Framer 0xc000181ce0: wrote GOAWAY len=8 LastStreamID=0 ErrCode=NO_ERROR Debug=""
2019/08/10 22:56:12 h2c: attempting h2c with prior knowledge.
2019/08/10 22:56:12 http2: server connection from [::1]:44510 on 0xc000269a00
2019/08/10 22:56:12 http2: Framer 0xc000181ea0: wrote SETTINGS len=24, settings: MAX_FRAME_SIZE=1048576, MAX_CONCURRENT_STREAMS=250, MAX_HEADER_LIST_SIZE=1048896, INITIAL_WINDOW_SIZE=1048576
2019/08/10 22:56:12 http2: server: client [::1]:44510 said hello
2019/08/10 22:56:12 http2: Framer 0xc000181ea0: read SETTINGS len=0
2019/08/10 22:56:12 http2: server read frame SETTINGS len=0
2019/08/10 22:56:12 http2: Framer 0xc000181ea0: wrote SETTINGS flags=ACK len=0
2019/08/10 22:56:12 http2: Framer 0xc000181ea0: wrote WINDOW_UPDATE len=4 (conn) incr=983041
2019/08/10 22:56:12 http2: Framer 0xc000181ea0: read SETTINGS flags=ACK len=0
2019/08/10 22:56:12 http2: server read frame SETTINGS flags=ACK len=0
... more GOAWAY frame from server and then new conn from grpcurl
Hi and thanks for awesome project! 👋
I guess it is thanks of forward and backward protobuf compatibility as you never know what server actually is implementing, but I just spent hour of crafting request in JSON only to get frustrated and coded Golang client in 2 minutes to find out that I was doing fields in snake_case instead of camelCase 🤦♂️
The request was coming through and even funnier -> It was succesful in some way due to default values.
Any way we can improve this? Either by validation or some tooling on how to craft the request? I guess you are parsing against given proto so it's clear that user uses field that does not exists? (:
I am getting a TLS handshake error even when I specify the -insecure
option
Can you please help me understand what is going on
$ grpcurl -v -insecure localhost:9000 list
Failed to dial target host "localhost:9000": tls: first record does not look like a TLS handshake
main:
func main() {
lis, err := net.Listen("tcp", "localhost:9000")
if err != nil {
log.Fatal(err)
}
srv := grpc.NewServer()
foo.RegisterFooServer(srv, &foo.Server{})
srv.Serve(lis)
}
I have a service that has a method which outputs a very large data set (~8MB) which exceeds the default message size limit of gRPC (4MB). grpc-java has a property to increase this limit maxInboundMessageSize.
Can we add such a property to grpcurl as well?
$ grpcurl -plaintext -d {} 127.0.0.1:9090 my.example.Service.GetLargeDataSet
ERROR:
Code: ResourceExhausted
Message: grpc: received message larger than max (8259568 vs. 4194304)
Hello,
I am not sure if this is an issue with grpcurl or me not being able to use PowerShell.
I have a grpc java Server with Reflection turned on and am using this command to ping it:
grpcurl -plaintext localhost:50051 com.example.coffee.services.CoffeeMachine/Ping
This works just fine and it shows my response message in the Shell.
But when I try to add a request message with -d like shown in the Readme I keep getting invalid character Error
grpcurl -d '{"product":1}' -plaintext localhost:50051 com.example.coffee.services.CoffeeMachine/GetProduct
Error invoking method "com.example.coffee.services.CoffeeMachine/GetProduct": error getting request data: invalid character 'p' looking for beginning of object key string
When I throw the command in the git bash it does work.
This looked to me like a parsing issue, so I tried different types of quotes and escape characters to get it to work. I found some comment where one claimed that in Windows the executable handles character unspacing?
This type of escaping seems to work in CMD, but not in PowerShell
grpcurl -d "{\"product\":1}" -plaintext localhost:50051 com.example.coffee.services.CoffeeMachine/GetProduct
Would be really grateful to find out how to use this tool in PowerShell on Windows.
Thanks a lot!
Headers are currently not sent along with service/method discovery calls. This prevents grpcurl from being used with any server that for example performs custom header-based authentication.
Any particular reasoning behind the decision not to send headers with the discovery calls? I think it would be sensible for any server performing (custom) authentication/authorization before executing a service call to extend the auth to the discovery of its services.
How can I make this tool accept self-signed certs?
I've been happily using grpcurl with something like the following:
grpcurl -plaintext -import-path ../../filter/api/services -proto myservice.proto localhost:50055 myservice.MyService/MyRPC
and it's been working fine for me.
Today a colleague reported issues running this same line.
After comparing versions of grpcurl, turnw out I was using:
grpcurl dev build <no version set>
and he was using:
grpcurl 1.3.0
So I brew install grpcurl to get on the same official version and now grpcurl complains:
Failed to process proto source files.: my_current_absolute_path/myservice.proto does not reside in any import path
This is failing:
grpcurl -plaintext -import-path ../../filter/api/services -proto myservice.proto localhost:50055 myservice.MyService/MyRPC
but this is working:
grpcurl -plaintext -proto ../../filter/api/services/myservice.proto localhost:50055 myservice.MyService/MyRPC
is there anything I'm doing wrong?
has anything changed around this area that would explain why previous version worked fine but current does not?
Add -d string
example in README.
I have a proto set with 3 gRPC services (and some external dependencies) that compiles appropriately on the protobuf side, compiles and runs in go, and clients work when interacting with the server, but reflection fails within grpcurl
on the 2 services which have dependencies in other packages.
I recreated a fake weatherman repo with a similar setup to provide an example.
proto & generated code repo: https://github.com/jamisonhyatt/grpc-multi-pkg-protos
Client gist: https://gist.github.com/jamisonhyatt/dd9d93b978472c960c9fa81b9f39fcf9
Here's tree
of the protoset
└── protos
├── desktop_svc
│ └── desktop_svc.proto
├── external
│ ├── location
│ │ └── location.proto
│ └── weather
│ ├── hurricanes.proto
│ └── weather.proto
├── mobile_svc
│ └── mobile_svc.proto
└── weatherman_svc.proto
list
returns
desktop.Desktop
grpc.reflection.v1alpha.ServerReflection
mobile.Mobile
weatherman.Weatherman
weatherman.Weatherman.Healthcheck
returns
{
"healthy": true
}
list mobile.Mobile
throws an error
Failed to list methods for service "mobile.Mobile": Symbol not found: mobile.Mobile
caused by: File not found: location/location.proto
I'd like to avoid refactoring the packages (which does work, but I have to flatten them) but I'd like to know of this is a symptom of how I have the packae imports, the gRPC reflection service, or the reflection in grpcurl
itself.
My feeling though, is that if the protos compile, the server compiles, the reflection service should have enough information to define the types. Any feedback is appreciated.
Edit: just for posterity, building the protosets and using those with grpcurl does work.
It would be great if grpcurl would have a switch that would allow to store protoset (and/or proto sources) to a file/directory. Maybe it could be a new flag that would work with describe
command, or a completely new command.
Our use-case: We want to automatically generate Envoy configuration with gRPC-JSON transcoder - it requires the protoset and list of services. grpcurl allows to list available services, just the protoset export is missing.
It might seem obvious but an small section in README file with installation instructions (make install) ,package dependencies (make), and configuration dependencies (GOBIN in $PATH) would be useful IMHO.
Hi! I love using grpcurl but installing it on new machines on first use can be pretty slow to download the dependencies and compile. Would it be possible to start releasing binaries?
Suggested approach I've used on my projects is to use goreleaser
to build binaries for a few operating systems and architectures, then it will upload them to the releases page of this project.
Is this something that could be added?
Thanks!
Hey, I'm very interested in this project but kinda new to go.
I have installed go on my mac, but how actually build binary?
How to install dependencies?
Thank you
Go get is failing with this error
# github.com/jhump/protoreflect/dynamic
../../../github.com/jhump/protoreflect/dynamic/json.go:960: undefined: jsonpb.AnyResolver
../../../github.com/jhump/protoreflect/dynamic/json.go:968: undefined: jsonpb.AnyResolver
go client code
auth := Authentication{
appKey: "duzhenxun",
appSecret: "password",
}
conn, err := grpc.Dial(*addr, grpc.WithInsecure(), grpc.WithPerRPCCredentials(&auth),grpc.WithAuthority("service1"))
Now I want to use curl to request how to add these parameters?
grpcurl -plaintext -authority service1 -d '{"name":"duzhenxun"}' ??????? 127.0.0.1:9080 hello.HelloService.Fun1
At Gophercon 2018, @jhump had an awesome gRPCurl demo program that imitated a bank API and admin actions on that API.
We should replace testing/test_server.go with that much more interactive demonstration.
exec grpcurl -plaintext host:port list
return Failed to list services: server does not support the reflection API
generate protoset
exec grpcurl -protoset *.protoset
return Too few arguments. Try 'grpcurl -help' for more details.
However, the help info can not help me in fact.
What is the crrect method to config protoset?
Thanks
Seem to be running into some issues using grpcurl with nginx-ingress
Specifically, i run
grpcurl -H 'content-type: application/grpc' mything.com:443 list
And get returned
Failed to list services: rpc error: code = Internal desc = transport: received the unexpected content-type "text/plain; charset=utf-8
Not sure if i'm meant to then add -reflect-header 'content-type: application/grpc'
, but doing so gets me no fruther.
The Service in question has TLS enabled at the service (pod) level, and it is valid using letsencrypt production certificate (I would expect a TLS error anyone on the CLI if something was wrong here?)
Any thoughts? Something i'm doing wrong to pass the header in? Tried to following the --help documentation but cant see where i'm passing the header incorrectly
grpcurl -d '...' localhost:50051 foo.Bar/Method | jq .status
{
...
}
parse error: Invalid numeric literal at line 7, column 5
The parse error: ...
is coming from jq
as it tries to parse the "Sent 1 request and received 1 response" log message that grpcurl outputs.
I'd like some way to ensure the stdout is clean JSON. Ideally by default.
Perhaps the "Sent 1 request and received 1 response" message could go to stderr, and/or only be output with -v
.
Hello ,
When i am try to run below comman 👍
grpcurl localhost:9081 describe .
I am getting below error :
Failed to dial target host "localhost:9081": tls: oversized record received with length 20527
Please help me out what i am doing wrong .
Thanks
Hi, I can't find any information about a possibility to connect to a unix socket. Can I or is this feature not available (yet)?
The maximum port number should be 65535, right?
When using the -keepalive-time
option, grpcurl
sends keepalive pings to the server at half the expected rate.
./grpcurl -keepalive-time 60 1.2.3.4:123 my.Service/ExtremelySlowAPI
tcpdump
to monitor packets being sent from grpcurl
to the service:tcpdump -i eth0 dst 1.2.3.4
You should see keepalive ping packets sent on the wire every 60 seconds.
tcpdump
reports 2 keepalive ping packets sent at once, every 120 seconds.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.