---
title: "Native gRPC Compatibility"
---

This guide explains how to make your Go Micro services compatible with native gRPC clients like `grpcurl`, `grpcui`, or clients generated by the standard `protoc` gRPC plugin in any language.

A complete, runnable version of everything in this guide lives in [`examples/grpc`](https://github.com/micro/go-micro/tree/master/examples/grpc).

## Understanding Transport vs Server

Go Micro has two different gRPC-related concepts that are often confused:

### gRPC Transport (`go-micro.dev/v6/transport/grpc`)

The gRPC **transport** uses the gRPC protocol as a communication layer, similar to how you might use NATS, RabbitMQ, or HTTP. It does **not** guarantee compatibility with native gRPC clients.

```go
// This uses gRPC as transport but is NOT compatible with native gRPC clients
import "go-micro.dev/v6/transport/grpc"

t := grpc.NewTransport()
service := micro.NewService("helloworld",
    micro.Transport(t),
)
```

When using the gRPC transport:
- Communication between Go Micro services works fine
- Native gRPC clients (grpcurl, etc.) will fail with "Unimplemented" errors
- The protocol is used like a message bus, not as a standard gRPC server

### gRPC Server/Client (`go-micro.dev/v6/server/grpc` and `go-micro.dev/v6/client/grpc`)

The gRPC **server** and **client** provide native gRPC compatibility. These implement a proper gRPC server that any gRPC client can communicate with.

```go
// This IS compatible with native gRPC clients
import (
    "go-micro.dev/v6"
    grpcServer "go-micro.dev/v6/server/grpc"
    grpcClient "go-micro.dev/v6/client/grpc"
)

service := micro.NewService("helloworld",
    micro.Server(grpcServer.NewServer()),
    micro.Client(grpcClient.NewClient()),
)
```

## When to Use Which

| Use Case | Solution |
|----------|----------|
| Need native gRPC client compatibility | Use gRPC server/client |
| Need to call service with `grpcurl` | Use gRPC server |
| Want `grpcurl`/`grpcui` to auto-discover methods (no `-proto` flag) | Add `grpcServer.Reflection()` |
| Need polyglot gRPC clients (Python, Java, etc.) | Use gRPC server |
| Only Go Micro services communicating | Either works |
| Want gRPC as a message protocol (like NATS) | Use gRPC transport |

## Complete Example: Native gRPC Compatible Service

### Proto Definition

```protobuf
syntax = "proto3";

package helloworld;
option go_package = "./proto;helloworld";

service Say {
    rpc Hello(Request) returns (Response) {}
}

message Request {
    string name = 1;
}

message Response {
    string message = 1;
}
```

### Generate Code

```bash
# Install protoc-gen-micro and the native gRPC plugin
go install go-micro.dev/v6/cmd/protoc-gen-micro@latest
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# Generate Go code (--go-grpc_out is needed for a native gRPC client)
protoc --proto_path=. \
    --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    --micro_out=. --micro_opt=paths=source_relative \
    proto/helloworld.proto
```

### Server Implementation

```go
package main

import (
    "context"
    "log"

    "go-micro.dev/v6"
    "go-micro.dev/v6/server"
    grpcServer "go-micro.dev/v6/server/grpc"
    pb "example.com/helloworld/proto"
)

type Say struct{}

func (s *Say) Hello(ctx context.Context, req *pb.Request, rsp *pb.Response) error {
    rsp.Message = "Hello " + req.Name
    return nil
}

func main() {
    // Create service with gRPC server for native gRPC compatibility.
    // The service name and address must be set on the gRPC server itself:
    // micro.NewService's Name/Address options are discarded when the default
    // server is swapped out.
    service := micro.NewService("helloworld",
        micro.Server(grpcServer.NewServer(
            server.Name("helloworld"),
            server.Address(":8080"),
            // Enable gRPC reflection so grpcurl and friends can discover
            // the service without local proto files.
            grpcServer.Reflection(),
        )),
    )

    service.Init()

    // Register handler
    pb.RegisterSayHandler(service.Server(), &Say{})

    // Run service
    if err := service.Run(); err != nil {
        log.Fatal(err)
    }
}
```

### Client Implementation (Go Micro)

```go
package main

import (
    "context"
    "fmt"
    "log"

    "go-micro.dev/v6"
    grpcClient "go-micro.dev/v6/client/grpc"
    pb "example.com/helloworld/proto"
)

func main() {
    // Create service with gRPC client
    service := micro.NewService("helloworld.client",
        micro.Client(grpcClient.NewClient()),
    )
    service.Init()

    // Create client - use the service name "helloworld" (not the proto package name)
    // Go Micro uses this name for registry lookup, which may differ from the package name
    sayService := pb.NewSayService("helloworld", service.Client())

    // Call service
    rsp, err := sayService.Hello(context.Background(), &pb.Request{Name: "Alice"})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(rsp.Message) // Output: Hello Alice
}
```

### Testing with grpcurl

Once your service is running with the gRPC server and `grpcServer.Reflection()`, you can use `grpcurl`. Reflection lets `grpcurl` discover the service and its methods on the wire, so no local proto file is needed:

```bash
# List available services
grpcurl -plaintext localhost:8080 list

# Describe the service
grpcurl -plaintext localhost:8080 describe helloworld.Say

# Call the Hello method
grpcurl -plaintext \
    -d '{"name":"Alice"}' \
    localhost:8080 helloworld.Say.Hello
```

Without reflection, fall back to the `-proto` flag pointing at the `.proto` file.

## Using Both gRPC Server and Client Together

For full native gRPC compatibility (both inbound and outbound), use both:

```go
package main

import (
    "go-micro.dev/v6"
    "go-micro.dev/v6/server"
    grpcClient "go-micro.dev/v6/client/grpc"
    grpcServer "go-micro.dev/v6/server/grpc"
)

func main() {
    service := micro.NewService("helloworld",
        micro.Server(grpcServer.NewServer(
            server.Name("helloworld"),
            server.Address(":8080"),
            grpcServer.Reflection(),
        )),
        micro.Client(grpcClient.NewClient()),
    )

    service.Init()
    // ... register handlers
    service.Run()
}
```

## Common Errors

### "unknown service" Error with grpcurl

If you see this error:

```
ERROR:
  Code: Unimplemented
  Message: unknown service helloworld.Say
```

**Cause**: You're using the gRPC transport instead of the gRPC server.

**Solution**: Change from:

```go
// Wrong - uses transport
t := grpc.NewTransport()
service := micro.NewService("helloworld",
    micro.Transport(t),
)
```

To:

```go
// Correct - uses server
import grpcServer "go-micro.dev/v6/server/grpc"

service := micro.NewService("helloworld",
    micro.Server(grpcServer.NewServer()),
)
```

### `grpcurl list` fails with "reflection service is not implemented"

If you see:

```
ERROR:
  Code: Unimplemented
  Message: unknown service grpc.reflection.v1alpha.ServerReflection
```

**Cause**: The gRPC server was created without the `Reflection()` option.

**Solution**: Add `grpcServer.Reflection()` to the server options so gRPC's
reflection service is registered.

### Service Name Not Set on the gRPC Server

**Symptom**: The service registers under the default name, or handlers can't be
found when a client looks up the name passed to `micro.NewService`.

**Cause**: The service name passed to `micro.NewService("helloworld", ...)` is
discarded when you swap in a gRPC server via `micro.Server(...)`.

**Solution**: Set the name on the gRPC server itself:

```go
service := micro.NewService("helloworld",
    micro.Server(grpcServer.NewServer(
        server.Name("helloworld"),
    )),
)
```

### Import Path Confusion

Note the different import paths:

```go
// Transport (NOT native gRPC compatible)
import "go-micro.dev/v6/transport/grpc"

// Server (native gRPC compatible)
import "go-micro.dev/v6/server/grpc"

// Client (native gRPC compatible)
import "go-micro.dev/v6/client/grpc"
```

### Service Name vs Package Name

When creating a client to call another service, use the **service name** passed to `micro.NewService`, not the proto package name:

```go
// If the server was started with micro.NewService("helloworld", ...)
sayService := pb.NewSayService("helloworld", service.Client())  // Use service name

// NOT the package name from the proto file
// sayService := pb.NewSayService("helloworld.Say", service.Client())  // Wrong!
```

Go Micro uses the service name for registry lookup, which may differ from the proto package name.

## Environment Variable Configuration

You can also configure the server and client via environment variables:

```bash
# Use gRPC server
MICRO_SERVER=grpc go run main.go

# Use gRPC client
MICRO_CLIENT=grpc go run main.go
```

## Summary

| Component | Import Path | Native gRPC Compatible |
|-----------|-------------|----------------------|
| Transport | `go-micro.dev/v6/transport/grpc` | ❌ No |
| Server | `go-micro.dev/v6/server/grpc` | ✅ Yes |
| Client | `go-micro.dev/v6/client/grpc` | ✅ Yes |

For native gRPC compatibility with tools like `grpcurl` or polyglot clients, always use the gRPC **server** and **client** packages, not the transport.

## Related Documentation

- [Transport](../interfaces/transport/index.md) - Understanding transports in Go Micro
- [Plugins](../plugins.md) - Available plugins including gRPC
- [Migration from gRPC](migration/from-grpc.md) - Migrating existing gRPC services
