gRPC Spring Boot Starter

https://grpc-ecosystem.github.io/grpc-spring/en/
Admin
gRPC Spring Boot Starter simplifies gRPC server and client setup by combining Google's...
Tokens:17,956
Snippets:214
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Configure Certificate Authentication

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Setup for certificate-based authentication using X509CertificateAuthenticationProvider.

```java
@Bean
AuthenticationManager authenticationManager() {
    final List<AuthenticationProvider> providers = new ArrayList<>();
    providers.add(new X509CertificateAuthenticationProvider(userDetailsService()));
    return new ProviderManager(providers);
}

@Bean
GrpcAuthenticationReader authenticationReader() {
    final List<GrpcAuthenticationReader> readers = new ArrayList<>();
    readers.add(new SSLContextGrpcAuthenticationReader());
    return new CompositeGrpcAuthenticationReader(readers);
}
```

--------------------------------

### Configure Basic Authentication

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Setup for Basic Auth using a ProviderManager and CompositeGrpcAuthenticationReader.

```java
@Bean
AuthenticationManager authenticationManager() {
    final List<AuthenticationProvider> providers = new ArrayList<>();
    providers.add(...); // Possibly DaoAuthenticationProvider
    return new ProviderManager(providers);
}

@Bean
GrpcAuthenticationReader authenticationReader() {
    final List<GrpcAuthenticationReader> readers = new ArrayList<>();
    readers.add(new BasicGrpcAuthenticationReader());
    return new CompositeGrpcAuthenticationReader(readers);
}
```

--------------------------------

### Implement a gRPC Service Class

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Example of a service implementation extending the generated base class and using the @GrpcService annotation.

```java
import example.HelloReply;
import example.HelloRequest;
import example.MyServiceGrpc;

import io.grpc.stub.StreamObserver;

import net.devh.boot.grpc.server.service.GrpcService;

@GrpcService
public class MyServiceImpl extends MyServiceGrpc.MyServiceImplBase {

    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
        HelloReply reply = HelloReply.newBuilder()
                .setMessage("Hello ==> " + request.getName())
                .build();
        responseObserver.onNext(reply);
        responseObserver.onCompleted();
    }

}
```

--------------------------------

### Configure Bearer Authentication

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Setup for OAuth2 or JWT bearer token authentication.

```java
@Bean
AuthenticationManager authenticationManager() {
    final List<AuthenticationProvider> providers = new ArrayList<>();
    providers.add(...); // Possibly JwtAuthenticationProvider
    return new ProviderManager(providers);
}

@Bean
GrpcAuthenticationReader authenticationReader() {
    final List<GrpcAuthenticationReader> readers = new ArrayList<>();
    // The actual token class is dependent on your spring-security library (OAuth2/JWT/...)
    readers.add(new BearerAuthenticationReader(accessToken -> new BearerTokenAuthenticationToken(accessToken)));
    return new CompositeGrpcAuthenticationReader(readers);
}
```

--------------------------------

### Example of NoClassDefFoundError stack trace

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

A typical stack trace indicating a missing class or method due to version conflicts.

```text
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'client' defined in file [~/.../MyGrpcClient.class]: Initialization of bean failed; nested exception is java.lang.NoClassDefFoundError: io/grpc/TlsChannelCredentials$Feature
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:602)
    [...]
Caused by: java.lang.NoClassDefFoundError: io/grpc/TlsChannelCredentials$Feature
    at io.grpc.netty.ProtocolNegotiators.<clinit>(ProtocolNegotiators.java:92)
```

--------------------------------

### Define a component with @GrpcClient

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Example of a Spring component that injects a gRPC blocking stub via the @GrpcClient annotation.

```java
@Component
public class MyComponent {

    private ChatServiceBlockingStub chatService;

    @GrpcClient("chatService")
    public void setChatService(ChatServiceBlockingStub chatService) {
        this.chatService = chatService;
    }

    public String sayHello(String name) {
        HelloRequest request = HelloRequest.newBuilder()
                .setName(name)
                .build();
        HelloReply reply = chatService.sayHello(name)
        return reply.getMessage();
    }

}
```

--------------------------------

### Discovering gRPC Services and Methods

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Use these commands to list available services, inspect method signatures, and view request message structures.

```bash
$ # First scan the server for available services
$ grpcurl --plaintext localhost:9090 list
net.devh.boot.grpc.example.MyService
$ # Then list the methods available for that call
$ grpcurl --plaintext localhost:9090 list net.devh.boot.grpc.example.MyService
net.devh.boot.grpc.example.MyService.SayHello
$ # Lets check the request and response types
$ grpcurl --plaintext localhost:9090 describe net.devh.boot.grpc.example.MyService/SayHello
net.devh.boot.grpc.example.MyService.SayHello is a method:
rpc SayHello ( .HelloRequest ) returns ( .HelloReply );
$ # Now we only have query for the request body structure
$ grpcurl --plaintext localhost:9090 describe net.devh.boot.grpc.example.HelloRequest
net.devh.boot.grpc.example.HelloRequest is a message:
message HelloRequest {
  string name = 1;
}
```

--------------------------------

### Dummy gRPC Service Implementation

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Implement a minimal gRPC service for testing purposes by extending the generated base class.

```java
@GrpcService
public class ChatServiceImplForMyComponentIntegrationTest extends ChatServiceGrpc.ChatServiceImplBase {

    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
        HelloReply response = HelloReply.newBuilder()
                .setMessage("Hello ==> " + request.getName())
                .build();
        responseObserver.onNext(response);
        responseObserver.onComplete();
    }

    // Methods that aren't used in the test don't need to be implemented

}
```

--------------------------------

### Configure InProcess Client

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/configuration.html

Connect to an InProcess server from within the same application.

```properties
grpc.client.inProcess.address=in-process:<SomeName>
```

--------------------------------

### Configure Gradle for gRPC Interface Project

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Sets up the protobuf plugin and dependencies to generate Java code from proto definitions.

```groovy
buildscript {
    ext {
        protobufVersion = '3.23.4'
        protobufPluginVersion = '0.8.18'
        grpcVersion = '1.58.0'
    }
}

plugins {
    id 'java-library'
    id 'com.google.protobuf' version "${protobufPluginVersion}"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    compileOnly 'jakarta.annotation:jakarta.annotation-api:1.3.5' // Java 9+ compatibility - Do NOT update to 2.0.0
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:${protobufVersion}"
    }
    generatedFilesBaseDir = "$projectDir/src/generated"
    clean {
        delete generatedFilesBaseDir
    }
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
        }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
        }
    }
}

// Optional
eclipse {
    classpath {
        file.beforeMerged { cp ->
            def generatedGrpcFolder = new org.gradle.plugins.ide.eclipse.model.SourceFolder('src/generated/main/grpc', null);
            generatedGrpcFolder.entryAttributes['ignore_optional_problems'] = 'true';
            cp.entries.add( generatedGrpcFolder );
            def generatedJavaFolder = new org.gradle.plugins.ide.eclipse.model.SourceFolder('src/generated/main/java', null);
            generatedJavaFolder.entryAttributes['ignore_optional_problems'] = 'true';
            cp.entries.add( generatedJavaFolder );
        }
    }
}

// Optional
idea {
    module {
        sourceDirs += file("src/generated/main/java")
        sourceDirs += file("src/generated/main/grpc")
        generatedSourceDirs += file("src/generated/main/java")
        generatedSourceDirs += file("src/generated/main/grpc")
    }
}
```

--------------------------------

### Define a gRPC service for testing

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

A sample gRPC service implementation using @GrpcService and dependency injection for testing purposes.

```java
@GrpcService
public class MyServiceImpl extends MyServiceGrpc.MyServiceImplBase {

    private OtherDependency foobar;

    @Autowired
    public void setFoobar(OtherDependency foobar) {
        this.foobar = foobar;
    }

    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
        HelloReply response = HelloReply.newBuilder()
                .setMessage("Hello ==> " + request.getName())
                .setCounter(foobar.getCount())
                .build();
        responseObserver.onNext(response);
        responseObserver.onComplete();
    }

}
```

--------------------------------

### Configure Maven Dependencies for gRPC Client

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/getting-started.html

Add the gRPC client starter and your interface module to the project dependencies.

```xml
    <dependencies>
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>example</groupId>
            <artifactId>my-grpc-interface</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
```

--------------------------------

### Configure Server for TLS

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Enable security and provide certificate paths in the server application configuration.

```properties
grpc.server.security.enabled=true
grpc.server.security.certificateChain=file:certificates/server.crt
grpc.server.security.privateKey=file:certificates/server.key
```

--------------------------------

### Configure Maven for gRPC Server Project

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Adds the gRPC Spring Boot starter dependency to a Maven project.

```xml
    <dependencies>
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-server-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>example</groupId>
            <artifactId>my-grpc-interface</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
```

--------------------------------

### Configure Gradle for gRPC Server Project

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Applies the Spring Boot plugin and adds necessary dependencies for a gRPC server.

```groovy
apply plugin: 'org.springframework.boot'

dependencies {
    compile('org.springframework.boot:spring-boot-starter')
    compile('net.devh:grpc-server-spring-boot-starter')
    compile('my-example:my-grpc-interface')
}

buildscript {
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
```

--------------------------------

### Implement a custom StubFactory

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/configuration.html

Create a custom StubFactory to support non-standard gRPC stub types by registering it in the application context.

```java
@Component
public class MyCustomStubFactory implements StubFactory {

    @Override
    public StubFactory<?> createStub(Class<? extends AbstractStub<?>> stubType, Channel channel) {
        try {
            Class<?> enclosingClass = stubType.getEnclosingClass();
            Method factoryMethod = enclosingClass.getMethod("newMyBetterFutureStub", Channel.class);
            return stubType.cast(factoryMethod.invoke(null, channel));
        } catch (Exception e) {
            throw new BeanInstantiationException(stubType, "Failed to create gRPC stub", e);
        }
    }

    @Override
    public boolean isApplicable(Class<? extends AbstractStub<?>> stubType) {
        return AbstractMyCustomStub.class.isAssignableFrom(stubType);
    }

}
```

--------------------------------

### Define a gRPC Service in Protobuf

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Place this definition in src/main/proto to allow build plugins to generate the necessary Java classes.

```protobuf
syntax = "proto3";

package net.devh.boot.grpc.example;

option java_multiple_files = true;
option java_package = "net.devh.boot.grpc.examples.lib";
option java_outer_classname = "HelloWorldProto";

// The greeting service definition.
service MyService {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {
    }
}

// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}

// The response message containing the greetings
message HelloReply {
    string message = 1;
}
```

--------------------------------

### Enable InProcessServer

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/configuration.html

Configure the server to use an InProcess transport to avoid network overhead.

```properties
grpc.server.in-process-name=<SomeName>
# Optional: Turn off the external grpc-server
#grpc.server.port=-1
```

--------------------------------

### Test gRPC Service with gRPCurl

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Commands to verify the gRPC service using gRPCurl, including variations for different operating systems.

```bash
grpcurl --plaintext localhost:9090 list
grpcurl --plaintext localhost:9090 list net.devh.boot.grpc.example.MyService
# Linux (Static content)
grpcurl --plaintext -d '{"name": "test"}' localhost:9090 net.devh.boot.grpc.example.MyService/sayHello
# Windows or Linux (dynamic content)
grpcurl --plaintext -d "{\"name\": \"test\"}" localhost:9090 net.devh.boot.grpc.example.MyService/sayHello
```

--------------------------------

### Configure Mockito MockMaker

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Create this file to enable mocking of final classes and methods in Mockito.

```text
mock-maker-inline

```

--------------------------------

### Manage gRPC dependencies with BOM

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Configuration snippets to enforce consistent gRPC library versions using the Bill of Materials (BOM).

```xml
<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-bom</artifactId>
    <version>${grpcVersion}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>
```

```groovy
dependencyManagement {
    imports {
        mavenBom "io.grpc:grpc-bom:${grpcVersion}"
```

--------------------------------

### Configure Gradle Dependencies for gRPC Client

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/getting-started.html

Include the Spring Boot plugin and necessary dependencies in your build.gradle file.

```groovy
apply plugin: 'org.springframework.boot'

dependencies {
    compile('org.springframework.boot:spring-boot-starter')
    compile('net.devh:grpc-client-spring-boot-starter')
    compile('my-example:my-grpc-interface')
}

buildscript {
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
```

--------------------------------

### Create Trusted Client Certificate Collection

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Concatenate client certificates into a single collection file.

```bash
cat client*.crt > trusted-clients.crt.collection
```

--------------------------------

### Add Brave gRPC dependency

Source: https://grpc-ecosystem.github.io/grpc-spring/en/brave.html

Include the Brave gRPC instrumentation library in your project build configuration.

```xml
<dependency>
    <groupId>io.zipkin.brave</groupId>
    <artifactId>brave-instrumentation-grpc</artifactId>
</dependency>
```

```groovy
compile("io.zipkin.brave:brave-instrumentation-grpc")
```

--------------------------------

### Implement Spring-based Integration Test

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Use Spring to manage dependencies during testing by providing a specific configuration class with mocked beans.

```java
@SpringBootTest
@SpringJUnitConfig(classes = { MyServiceUnitTestConfiguration.class })
// Spring doesn't start without a config (might be empty)
// Don't use @EnableAutoConfiguration in this scenario
public class MyServiceTest {

    @Autowired
    private MyServiceImpl myService;

    @Test
    void testSayHello() throws Exception {
        HelloRequest request = HelloRequest.newBuilder()
                .setName("Test")
                .build();
        StreamRecorder<HelloReply> responseObserver = StreamRecorder.create();
        myService.sayHello(request, responseObserver);
        if (!responseObserver.awaitCompletion(5, TimeUnit.SECONDS)) {
            fail("The call did not terminate in time");
        }
        assertNull(responseObserver.getError());
        List<HelloReply> results = responseObserver.getValues();
        assertEquals(1, results.size());
        HelloReply response = results.get(0);
        assertEquals(HelloReply.newBuilder()
                .setMessage("Hello ==> Test")
                .setCounter(1337)
                .build(), response);
    }

}
```

```java
@Configuration
public class MyServiceUnitTestConfiguration {

    @Bean
    OtherDependency foobar() {
        // return mock(OtherDependency.class);
    }

    @Bean
    MyServiceImpl myService() {
        return new MyServiceImpl();
    }

}
```

--------------------------------

### Configure Maven for gRPC Interface Project

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/getting-started.html

Defines dependencies and the protobuf-maven-plugin to generate gRPC stubs from proto files.

```xml
    <properties>
        <protobuf.version>3.23.4</protobuf.version>
        <protobuf-plugin.version>0.6.1</protobuf-plugin.version>
        <grpc.version>1.58.0</grpc.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <!-- Java 9+ compatibility - Do NOT update to 2.0.0 -->
            <groupId>jakarta.annotation</groupId>
            <artifactId>jakarta.annotation-api</artifactId>
            <version>1.3.5</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.7.0</version>
            </extension>
        </extensions>

        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>${protobuf-plugin.version}</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
```

--------------------------------

### Troubleshoot Untrusted Certificate Errors

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Identifies PKIX path building failures occurring when the server certificate is missing from the client trust store.

```text
io.grpc.StatusRuntimeException: UNAVAILABLE: io exception
[...]
Caused by: javax.net.ssl.SSLHandshakeException: General OpenSslEngine problem
[...]
Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
[...]
Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
```

--------------------------------

### Configure ManagedChannelBuilder

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/configuration.html

Implement GrpcChannelConfigurer to apply custom settings to the underlying ManagedChannelBuilder.

```java
@Bean
public GrpcChannelConfigurer keepAliveClientConfigurer() {
    return (channelBuilder, name) -> {
        if (channelBuilder instanceof NettyChannelBuilder) {
            ((NettyChannelBuilder) channelBuilder)
                    .keepAliveTime(30, TimeUnit.SECONDS)
                    .keepAliveTimeout(5, TimeUnit.SECONDS);
        }
    };
}
```

--------------------------------

### Customize ServerBuilder with GrpcServerConfigurer

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/configuration.html

Use a bean to apply custom configurations to the underlying ServerBuilder, such as Netty keep-alive settings.

```java
@Bean
public GrpcServerConfigurer keepAliveServerConfigurer() {
    return serverBuilder -> {
        if (serverBuilder instanceof NettyServerBuilder) {
            ((NettyServerBuilder) serverBuilder)
                    .keepAliveTime(30, TimeUnit.SECONDS)
                    .keepAliveTimeout(5, TimeUnit.SECONDS)
                    .permitKeepAliveWithoutCalls(true);
        }
    };
}
```

--------------------------------

### Add Actuator Dependency

Source: https://grpc-ecosystem.github.io/grpc-spring/en/actuator.html

Include the Spring Boot Actuator starter to enable automatic metric collection and actuator features.

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
```

```groovy
compile("org.springframework.boot:spring-boot-starter-actuator")
```

--------------------------------

### Add Spring Cloud Sleuth dependency

Source: https://grpc-ecosystem.github.io/grpc-spring/en/brave.html

Include the Spring Cloud Sleuth starter to automatically configure the Tracing bean.

```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
```

```groovy
compile("org.springframework.cloud:spring-cloud-starter-sleuth")
```

--------------------------------

### Generate Self-Signed Certificates with OpenSSL

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Use this command to generate a self-signed certificate and private key for internal testing purposes.

```bash
openssl req -x509 -nodes -subj "//CN=localhost" -newkey rsa:4096 -sha256 -keyout server.key -out server.crt -days 3650
```

--------------------------------

### Configure Custom Trusted Certificate File

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Sets a custom path for the trusted certificate collection to resolve trust store issues.

```properties
grpc.client.__name__.security.trustCertCollection=file:certificates/trusted-servers-collection.crt.list
```

--------------------------------

### Identify missing TLS ALPN provider on client

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

This stack trace indicates that no compatible TLS ALPN provider is available on the client classpath.

```text
[...]
Caused by: java.lang.IllegalStateException: Failed to create channel: <name>
    at net.devh.boot.grpc.client.inject.GrpcClientBeanPostProcessor.processInjectionPoint(GrpcClientBeanPostProcessor.java:118) ~[grpc-client-spring-boot-starter-2.4.0.RELEASE.jar:2.4.0.RELEASE]
    at net.devh.boot.grpc.client.inject.GrpcClientBeanPostProcessor.postProcessBeforeInitialization(GrpcClientBeanPostProcessor.java:77)
    [...]
Caused by: java.lang.IllegalStateException: Could not find TLS ALPN provider; no working netty-tcnative, Conscrypt, or Jetty NPN/ALPN available
    at io.grpc.netty.GrpcSslContexts.defaultSslProvider(GrpcSslContexts.java:258) ~[grpc-netty-1.21.0.jar:1.21.0]
    at io.grpc.netty.GrpcSslContexts.configure(GrpcSslContexts.java:171) ~[grpc-netty-1.21.0.jar:1.21.0]
    at io.grpc.netty.GrpcSslContexts.forClient(GrpcSslContexts.java:120) ~[grpc-netty-1.21.0.jar:1.21.0]
    [...]
```

--------------------------------

### Implement Standalone Unit Test

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Perform unit tests without external framework dependencies by manually instantiating the service and mocking dependencies.

```java
public class MyServiceTest {

    private MyServiceImpl myService;

    @BeforeEach
    public void setup() {
        myService = new MyServiceImpl();
        OtherDependency foobar = ...; // mock(OtherDependency.class)
        myService.setFoobar(foobar);
    }

    @Test
    void testSayHello() throws Exception {
        HelloRequest request = HelloRequest.newBuilder()
                .setName("Test")
                .build();
        StreamRecorder<HelloReply> responseObserver = StreamRecorder.create();
        myService.sayHello(request, responseObserver);
        if (!responseObserver.awaitCompletion(5, TimeUnit.SECONDS)) {
            fail("The call did not terminate in time");
        }
        assertNull(responseObserver.getError());
        List<HelloReply> results = responseObserver.getValues();
        assertEquals(1, results.size());
        HelloReply response = results.get(0);
        assertEquals(HelloReply.newBuilder()
                .setMessage("Hello ==> Test")
                .setCounter(1337)
                .build(), response);
    }

}
```

--------------------------------

### Configure gRPC address

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Ensure the address includes the correct port to avoid protocol mismatches.

```text
dns:///my-service.grpc.example -> dns:///my-service.grpc.example:12345
```

--------------------------------

### Identify gRPC Server BindException

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Stack trace indicating a failure to bind the gRPC server due to an address already in use.

```text
Caused by: java.lang.IllegalStateException: Failed to start the grpc server
    at net.devh.boot.grpc.server.serverfactory.GrpcServerLifecycle.start(GrpcServerLifecycle.java:51) ~[grpc-server-spring-boot-starter-2.4.0.RELEASE.jar:2.4.0.RELEASE]
    [...]
Caused by: java.io.IOException: Failed to bind
    at io.grpc.netty.shaded.io.grpc.netty.NettyServer.start(NettyServer.java:246) ~[grpc-netty-shaded-1.21.0.jar:1.21.0]
    at io.grpc.internal.ServerImpl.start(ServerImpl.java:177) ~[grpc-core-1.21.0.jar:1.21.0]
    at io.grpc.internal.ServerImpl.start(ServerImpl.java:85) ~[grpc-core-1.21.0.jar:1.21.0]
    at net.devh.boot.grpc.server.serverfactory.GrpcServerLifecycle.createAndStartGrpcServer(GrpcServerLifecycle.java:90) ~[grpc-server-spring-boot-starter-2.4.0.RELEASE.jar:2.4.0.RELEASE]
    at net.devh.boot.grpc.server.serverfactory.GrpcServerLifecycle.start(GrpcServerLifecycle.java:49) ~[grpc-server-spring-boot-starter-2.4.0.RELEASE.jar:2.4.0.RELEASE]
    ... 13 common frames omitted
Caused by: java.net.BindException: Address already in use: bind
```

--------------------------------

### Integration Test Configuration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Define the configuration class required to set up the in-process server and necessary beans for integration tests.

```java
@Configuration
@ImportAutoConfiguration({
        GrpcServerAutoConfiguration.class, // Create required server beans
        GrpcServerFactoryAutoConfiguration.class, // Select server implementation
        GrpcClientAutoConfiguration.class}) // Support @GrpcClient annotation
public class MyComponentIntegrationTestConfiguration {

    @Bean
    MyComponent myComponent() {
        return new MyComponent();
    }

    @Bean
    ChatServiceImplForMyComponentIntegrationTest chatServiceImpl() {
        return new ChatServiceImplForMyComponentIntegrationTest();
    }

}
```

--------------------------------

### Enable Info Endpoint Configuration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/actuator.html

Configuration properties to enable the info endpoint in Spring Boot Actuator.

```properties
management.endpoints.web.exposure.include=info
#management.endpoints.jmx.exposure.include=info
management.endpoint.info.enabled=true
```

--------------------------------

### Troubleshoot Certificate Mismatch Errors

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Identifies SSL handshake exceptions caused by missing subject alternative names or hostname mismatches.

```text
io.grpc.StatusRuntimeException: UNAVAILABLE: io exception
[...]
Caused by: javax.net.ssl.SSLHandshakeException: General OpenSslEngine problem
[...]
Caused by: java.security.cert.CertificateException: No subject alternative names present
```

```text
io.grpc.StatusRuntimeException: UNAVAILABLE: io exception
[...]
Caused by: javax.net.ssl.SSLHandshakeException: General OpenSslEngine problem
[...]
Caused by: java.security.cert.CertificateException: No name matching <name> found
```

--------------------------------

### Identify missing TLS ALPN provider on server

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

This stack trace indicates that no compatible TLS ALPN provider is available on the server classpath.

```text
org.springframework.context.ApplicationContextException: Failed to start bean 'nettyGrpcServerLifecycle'; nested exception is java.lang.IllegalStateException: Could not find TLS ALPN provider; no working netty-tcnative, Conscrypt, or Jetty NPN/ALPN available
    at org.springframework.context.support.DefaultLifecycleProcessor.doStart(DefaultLifecycleProcessor.java:185) ~[spring-context-5.1.8.RELEASE.jar:5.1.8.RELEASE]
    [...]
Caused by: java.lang.IllegalStateException: Could not find TLS ALPN provider; no working netty-tcnative, Conscrypt, or Jetty NPN/ALPN available
    at io.grpc.netty.GrpcSslContexts.defaultSslProvider(GrpcSslContexts.java:258) ~[grpc-netty-1.21.0.jar:1.21.0]
    at io.grpc.netty.GrpcSslContexts.configure(GrpcSslContexts.java:171) ~[grpc-netty-1.21.0.jar:1.21.0]
    at io.grpc.netty.GrpcSslContexts.forServer(GrpcSslContexts.java:130) ~[grpc-netty-1.21.0.jar:1.21.0]
    [...]
```

--------------------------------

### Test Plaintext Configuration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Demonstrates how to apply plaintext negotiation settings within a Spring Boot test environment.

```java
@SpringBootTest(properties = "grpc.client.test.negotiationType=PLAINTEXT")
@SpringJUnitConfig(classes = TestConfig.class)
@DirtiesContext
public class PlaintextSetupTest {

    @GrpcClient("test")
    private MyServiceBlockingStub myService;
```

--------------------------------

### Configure CallCredentials per Stub

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Apply credentials just-in-time to a specific stub instance for user-dependent authentication.

```java
MyServiceBlockingStub myServiceForUser = myService.withCallCredentials(userCredentials);
return myServiceForUser.send(request);
```

--------------------------------

### Configuring gRPC Stubs with @GrpcClientBean

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/getting-started.html

Use @GrpcClientBean within a configuration class to define stubs as beans for broader usage across services.

```java
@Configuration
@GrpcClientBean(
    clazz = TestServiceGrpc.TestServiceBlockingStub.class,
    beanName = "blockingStub",
    client = @GrpcClient("test")
)
public class YourCustomConfiguration {

    @Bean
    FoobarService foobarService(@Autowired TestServiceGrpc.TestServiceBlockingStub blockingStub) {
        return new FoobarService(blockingStub);
    }

}

@Service
@AllArgsConstructor
public class FoobarService {

    private TestServiceBlockingStub blockingStub;

    public String receiveGreeting(String name) {
        HelloRequest request = HelloRequest.newBuilder()
                .setName(name)
                .build();
        return blockingStub.sayHello(request).getMessage();
    }

}
```

--------------------------------

### Executing gRPC Method Calls

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Invoke gRPC methods with or without a request body using the gRPCurl command.

```bash
$ # Finally we can call the actual method
$ grpcurl --plaintext localhost:9090 net.devh.boot.grpc.example.MyService/SayHello
{
  "message": "Hello ==> ",
  "counter": 1337
}
$ # Or call it with a populated request body
$ grpcurl --plaintext -d '{"name": "Test"}' localhost:9090 net.devh.boot.grpc.example.MyService/SayHello
{
  "message": "Hello ==> Test",
  "counter": 1337
}
```

--------------------------------

### Integration Test with In-Process Server

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Configure a Spring Boot test to use an in-process gRPC server for integration testing.

```java
@SpringBootTest(properties = {
        "grpc.server.inProcessName=test", // Enable inProcess server
        "grpc.server.port=-1", // Disable external server
        "grpc.client.chatService.address=in-process:test" // Configure the client to connect to the inProcess server
        })
@SpringJUnitConfig(classes = { MyComponentIntegrationTestConfiguration.class })
// Spring doesn't start without a config (might be empty)
@DirtiesContext // Ensures that the grpc-server is properly shutdown after each test
        // Avoids "port already in use" during tests
public class MyComponentTest {

    @Autowired
    private MyComponent myComponent;

    @Test
    @DirtiesContext
    void testSayHello() {
        assertThat(myComponent.sayHello("ThisIsMyName")).contains("ThisIsMyName");
    }

}
```

--------------------------------

### Identify AbstractMethodError for TLS

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

This error indicates a missing or incompatible netty TLS implementation.

```text
AbstractMethodError: io.netty.internal.tcnative.SSL.readFromSSL()
```

--------------------------------

### Configure Target Server Address

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/configuration.html

Sets the target server address for a specific gRPC client using the static scheme.

```properties
grpc.client.__name__.address=static://localhost:9090
```

--------------------------------

### Identify First received frame was not SETTINGS error

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

This error indicates a protocol mismatch, often caused by connecting to a non-gRPC web server.

```text
Status{code=INTERNAL, description=http2 exception, cause=...Http2Exception: First received frame was not SETTINGS. Hex dump for first 5 bytes: 485454502f
```

--------------------------------

### Configure Mutual Certificate Authentication

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Set these properties in your application configuration to enable client certificate authentication.

```properties
grpc.client.__name__.security.clientAuthEnabled=true
grpc.client.__name__.security.certificateChain=file:certificates/client.crt
grpc.client.__name__.security.privateKey=file:certificates/client.key
```

--------------------------------

### Configure gRPC Server TLS Properties

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Add these properties to your Spring configuration to enable TLS and specify the certificate chain and private key files.

```properties
grpc.server.security.enabled=true
grpc.server.security.certificateChain=file:certificates/server.crt
grpc.server.security.privateKey=file:certificates/server.key
#grpc.server.security.privateKeyPassword=MyStrongPassword
```

--------------------------------

### Define Kubernetes Service for gRPC

Source: https://grpc-ecosystem.github.io/grpc-spring/en/kubernetes.html

Map the service port to the target port defined in your deployment. Use the name 'grpclb' if you intend to use DNS-SVC-Lookups.

```yaml
apiVersion: v1
kind: Service
metadata:
  name: my-grpc-server-app # This name is important
  namespace: example # This name might be important
spec:
  selector:
    app: my-grpc-server-app
  ports:
    - name: grpclb # The name is important, if you wish to use DNS-SVC-Lookups (must be grpclb)
      port: 1234 # Remember this port number, unless you use DNS-SVC-Lookups (prefer 80, 443 or 9090)
      targetPort: grpc # Use the port name from the deployment (or just the port number)
```

--------------------------------

### Enable Metrics Endpoint Configuration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/actuator.html

Configuration properties to enable the metrics endpoint in Spring Boot Actuator.

```properties
management.endpoints.web.exposure.include=metrics
#management.endpoints.jmx.exposure.include=metrics
management.endpoint.metrics.enabled=true
```

--------------------------------

### Configure gRPC Integration Test Class

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Uses @SpringBootTest to configure an in-process server and client for testing the full stack without external network dependencies.

```java
@SpringBootTest(properties = {
        "grpc.server.inProcessName=test", // Enable inProcess server
        "grpc.server.port=-1", // Disable external server
        "grpc.client.inProcess.address=in-process:test" // Configure the client to connect to the inProcess server
        })
@SpringJUnitConfig(classes = { MyServiceIntegrationTestConfiguration.class })
// Spring doesn't start without a config (might be empty)
@DirtiesContext // Ensures that the grpc-server is properly shutdown after each test
        // Avoids "port already in use" during tests
public class MyServiceTest {

    @GrpcClient("inProcess")
    private MyServiceBlockingStub myService;

    @Test
    @DirtiesContext
    public void testSayHello() {
        HelloRequest request = HelloRequest.newBuilder()
                .setName("test")
                .build();
        HelloReply response = myService.sayHello(request);
        assertNotNull(response);
        assertEquals("Hello ==> Test", response.getMessage())
    }

}
```

--------------------------------

### Enable Spring Method Security

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Enable method-level security in a configuration class. proxyTargetClass = true is mandatory to avoid UNIMPLEMENTED responses.

```java
@EnableMethodSecurity(proxyTargetClass = true)
```

--------------------------------

### Configure GrpcSecurityMetadataSource and AccessDecisionManager

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/security.html

Define security rules per gRPC method and configure the AccessDecisionManager to process AccessPredicates.

```java
import net.devh.boot.grpc.server.security.check.AccessPredicate;
import net.devh.boot.grpc.server.security.check.ManualGrpcSecurityMetadataSource;

@Bean
GrpcSecurityMetadataSource grpcSecurityMetadataSource() {
    final ManualGrpcSecurityMetadataSource source = new ManualGrpcSecurityMetadataSource();
    source.set(MyServiceGrpc.getMethodA(), AccessPredicate.authenticated());
    source.set(MyServiceGrpc.getMethodB(), AccessPredicate.hasRole("ROLE_USER"));
    source.set(MyServiceGrpc.getMethodC(), AccessPredicate.hasAllRole("ROLE_FOO", "ROLE_BAR"));
    source.set(MyServiceGrpc.getMethodD(), (auth, call) -> "admin".equals(auth.getName()));
    source.setDefault(AccessPredicate.denyAll());
    return source;
}

@Bean
AccessDecisionManager accessDecisionManager() {
    final List<AccessDecisionVoter<?>> voters = new ArrayList<>();
    voters.add(new AccessPredicateVoter());
    return new UnanimousBased(voters);
}
```

--------------------------------

### Configure TLS Negotiation Type

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Sets the negotiation type to TLS for a specific gRPC client.

```properties
grpc.client.<SomeName>.negotiationType=TLS
```

--------------------------------

### Define Integration Test Configuration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Provides the necessary auto-configuration classes and bean definitions required for the integration test context.

```java
@Configuration
@ImportAutoConfiguration({
        GrpcServerAutoConfiguration.class, // Create required server beans
        GrpcServerFactoryAutoConfiguration.class, // Select server implementation
        GrpcClientAutoConfiguration.class}) // Support @GrpcClient annotation
public class MyServiceIntegrationTestConfiguration {

    @Bean
    OtherDependency foobar() {
        return ...; // mock(OtherDependency.class);
    }

    @Bean
    MyServiceImpl myServiceImpl() {
        return new MyServiceImpl();
    }

}
```

--------------------------------

### Identify gRPC Client Resolution Errors

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Log output indicating a failure to resolve a target address due to missing scheme configuration.

```text
WARN  io.grpc.internal.ManagedChannelImpl - [Failed to resolve name. status=Status{code=UNAVAILABLE, description=No servers found for `discovery-server:443`}
ERROR n.d.b.g.c.n.DiscoveryClientNameResolver - No servers found for `discovery-server:443`
```

--------------------------------

### Add test dependencies for Gradle

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Required dependencies for JUnit, gRPC testing, Spring Boot test support, and Mockito in a Gradle project.

```groovy
// JUnit-Test-Framework
testImplementation("org.junit.jupiter:junit-jupiter-api")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
// Grpc-Test-Support
testImplementation("io.grpc:grpc-testing")
// Spring-Test-Support (Optional)
testImplementation("org.springframework.boot:spring-boot-starter-test")
// Mocking Framework (Optional)
testImplementation("org.mockito:mockito-all")
```

--------------------------------

### Unit Test with Mocked Stub

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Inject a mocked gRPC stub into a component using a setter method before executing tests.

```java
public class MyComponentTest {

    private MyComponent myComponent = new MyComponent();
    private ChatServiceBlockingStub chatService = Mockito.mock(ChatServiceBlockingStub.class);

    @BeforeEach
    void setup() {
        myComponent.setChatService(chatService);
    }

    @Test
    void testSayHello() {
        Mockito.when(chatService.sayHello(...)).thenAnswer(...);
        assertThat(myComponent.sayHello("ThisIsMyName")).contains("ThisIsMyName");
    }

}
```

--------------------------------

### Configure Trusted Server Certificates

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Specifies a custom trust certificate collection for a gRPC client.

```properties
grpc.client.__name__.security.trustCertCollection=file:trusted-server.crt.collection
```

--------------------------------

### Define Global Exception Handling with @GrpcAdvice

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/exception-handling.html

Use @GrpcAdvice to mark a class for exception handling and @GrpcExceptionHandler to define methods that catch specific exceptions and return gRPC status objects.

```java
@GrpcAdvice
public class GrpcExceptionAdvice {


    @GrpcExceptionHandler
    public Status handleInvalidArgument(IllegalArgumentException e) {
        return Status.INVALID_ARGUMENT.withDescription("Your description").withCause(e);
    }

    @GrpcExceptionHandler(ResourceNotFoundException.class)
    public StatusException handleResourceNotFoundException(ResourceNotFoundException e) {
        Status status = Status.NOT_FOUND.withDescription("Your description").withCause(e);
        Metadata metadata = ...
        return status.asException(metadata);
    }

}
```

--------------------------------

### Configure Unix Domain Sockets

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/configuration.html

Set the server address to use Unix domain sockets for local communication.

```properties
grpc.server.address=unix:/run/grpc-server
```

--------------------------------

### Configure Authority Override

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Overrides the default name comparison logic when the certificate does not match the target address.

```properties
grpc.client.__name__.security.authorityOverride=<authority>
```

--------------------------------

### Disable TLS for Development

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Configures a client to use plaintext instead of TLS. Do not use this in production environments.

```properties
grpc.client.__name__.negotiationType=PLAINTEXT
```

--------------------------------

### Executing gRPC Calls on Windows

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/testing.html

Use double quotes and escape internal JSON quotes when running gRPCurl on Windows terminals.

```bash
grpcurl --plaintext -d "{\"name\": \"Test\"}" localhost:9090 net.devh.boot.grpc.example.MyService/sayHello
{
  "message": "Hello ==> Test",
  "counter": 1337
}
```

--------------------------------

### Identify Client-side Transport Failure

Source: https://grpc-ecosystem.github.io/grpc-spring/en/trouble-shooting.html

Stack trace showing a NotSslRecordException, indicating the client is attempting TLS on a plaintext server.

```text
io.grpc.StatusRuntimeException: UNAVAILABLE: io exception
    at io.grpc.stub.ClientCalls.toStatusRuntimeException(ClientCalls.java:235)
    at io.grpc.stub.ClientCalls.getUnchecked(ClientCalls.java:216)
    at io.grpc.stub.ClientCalls.blockingUnaryCall(ClientCalls.java:141)
    at net.devh.boot.grpc.examples.lib.SimpleGrpc$SimpleBlockingStub.sayHello(SimpleGrpc.java:178)
    [...]
Caused by: io.grpc.netty.shaded.io.netty.handler.ssl.NotSslRecordException: not an SSL/TLS record: 00001204000000000000037fffffff000400100000000600002000000004080000000000000f0001
    at io.grpc.netty.shaded.io.netty.handler.ssl.SslHandler.decodeJdkCompatible(SslHandler.java:1204)
    at io.grpc.netty.shaded.io.netty.handler.ssl.SslHandler.decode(SslHandler.java:1272)
    at io.grpc.netty.shaded.io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:502)
```

--------------------------------

### Add test dependencies for Maven

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/testing.html

Required dependencies for JUnit, gRPC testing, Spring Boot test support, and Mockito in a Maven project.

```xml
<!-- JUnit-Test-Framework -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>
<!-- Grpc-Test-Support -->
<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-testing</artifactId>
    <scope>test</scope>
</dependency>
<!-- Spring-Test-Support (Optional) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- Mocking Framework (Optional) -->
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <scope>test</scope>
</dependency>
```

--------------------------------

### Create Injectable gRPC Client Beans

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/configuration.html

Use @GrpcClientBean to expose @GrpcClient instances as injectable beans within your Spring configuration.

```java
@Configuration
@GrpcClientBean(
    clazz = TestServiceBlockingStub.class,
    beanName = "blockingStub",
    client = @GrpcClient("test")
)
@GrpcClientBean(
    clazz = FactoryMethodAccessibleStub.class,
    beanName = "accessibleStub",
    client = @GrpcClient("test"))
public class YourCustomConfiguration {

    @Bean
    FooService fooServiceBean(@Autowired TestServiceGrpc.TestServiceBlockingStub blockingStub) {
        return new FooService(blockingStub);
    }

}

@Service
@AllArgsConsturtor
public class BarService {

    private FactoryMethodAccessibleStub accessibleStub;

    public String receiveGreeting(String name) {
        HelloRequest request = HelloRequest.newBuilder()
                .setName(name)
                .build();
        return accessibleStub.sayHello(request).getMessage();
    }

}
```

--------------------------------

### Enable gRPC Actuator Health Integration

Source: https://grpc-ecosystem.github.io/grpc-spring/en/actuator.html

Configure the gRPC server to use Spring Boot Actuator for health checks.

```properties
grpc.server.health-service.type=ACTUATOR
```

--------------------------------

### Change gRPC Server Port

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/configuration.html

Set the server port via properties. Use 0 to assign a random free port.

```properties
grpc.server.port=80
```

--------------------------------

### Define CallCredentials Beans

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/security.html

Create beans for BasicAuth or bearer token authentication to be automatically used by the gRPC client.

```java
@Bean
CallCredentials basicAuthCredentials() {
    return CallCredentialsHelper.basicAuth("user", "password");
}

@Bean
CallCredentials bearerAuthForwardingCredentials() {
    return CallCredentialsHelper.bearerAuth(() -> KeycloakSecurityContext.getTokenString());
}
```

--------------------------------

### Injecting a gRPC Stub with @GrpcClient

Source: https://grpc-ecosystem.github.io/grpc-spring/en/client/getting-started.html

Use the @GrpcClient annotation to inject a specific gRPC stub directly into a Spring service.

```java
import example.HelloRequest;
import example.MyServiceGrpc.MyServiceBlockingStub;

import net.devh.boot.grpc.client.inject.GrpcClient;

import org.springframework.stereotype.Service;

@Service
public class FoobarService {

    @GrpcClient("myService")
    private MyServiceBlockingStub myServiceStub;

    public String receiveGreeting(String name) {
        HelloRequest request = HelloRequest.newBuilder()
                .setName(name)
                .build();
        return myServiceStub.sayHello(request).getMessage();
    }

}
```

--------------------------------

### Include Metadata in Exception Responses

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/exception-handling.html

Return a StatusRuntimeException or StatusException to include custom Metadata in the gRPC error response.

```java
@GrpcExceptionHandler
public StatusRuntimeException handleResourceNotFoundException(IllegalArgumentException e) {
    Status status = Status.INVALID_ARGUMENT.withDescription("Your description");
    Metadata metadata = ...
    return status.asRuntimeException(metadata);
}
```

--------------------------------

### Configure gRPC client address in Spring

Source: https://grpc-ecosystem.github.io/grpc-spring/en/kubernetes.html

Set the channel address using the dns:/// scheme to resolve the service name within the cluster.

```properties
## Choose your matching variant
# Same namespace (target port=80 or derived by DNS-SVC)
grpc.client.my-grpc-server-app.address=dns:///my-grpc-server-app
# Same namespace (different port)
grpc.client.my-grpc-server-app.address=dns:///my-grpc-server-app:1234
# Different namespace
grpc.client.my-grpc-server-app.address=dns:///my-grpc-server-app.example:1234
# Different cluster
grpc.client.my-grpc-server-app.address=dns:///my-grpc-server-app.example.svc.cluster.local:1234
# Format
grpc.client.my-grpc-server-app.address=dns:///<serviceName>[.<namespace>[.<clusterAddress>]][:<service-port>]
```

--------------------------------

### Subscribe to gRPC Server Events

Source: https://grpc-ecosystem.github.io/grpc-spring/en/server/events.html

Use the @EventListener annotation on a public method within a Spring @Component to handle server lifecycle events.

```java
@Component
public class MyEventListenerComponent {

    @EventListener
    public void onServerStarted(GrpcServerStartedEvent event) {
        System.out.println("gRPC Server started, listening on address: " + event.getAddress() + ", port: " + event.getPort());
    }

}
```
Tokens:
Raw