gRPC has been around since 2015, and it has undergone several significant changes over the years.
The first version of gRPC, version 0.1, was released in 2015. This initial release laid the foundation for the framework's future development.
With the release of version 1.0 in 2017, gRPC gained more widespread adoption and became a popular choice for building microservices. This version introduced several key features, including HTTP/2 support and streaming capabilities.
gRPC version 1.4, released in 2018, brought significant performance improvements and better support for load balancing. This version also introduced the concept of "reflection", which allows clients to dynamically discover service methods.
If this caught your attention, see: Does Dropbox Support Version Tracking
gRPC Versions
gRPC Versions are managed through a clear policy.
The gRPC versioning policy is documented online.
You can find the latest gRPC Version by checking the release tag.
The latest release tag is v1.74.0.
gRPC Versions are updated regularly, so it's a good idea to check the latest version.
The policy for versioning is available for anyone to see.
Related reading: Onedrive Latest Version
gRPC Versioning Policy
The gRPC versioning policy is designed to ensure compatibility and flexibility. Major version 1.x.x is End Of Life (EOL) and no longer receives updates.
The current major version is 3.x.x, which will receive updates if there are new releases in Spring Boot or gRPC. Minor versions define feature versions, and incrementing the minor version is necessary when adding or changing major features.
Here are some examples of non-breaking changes that gRPC supports:
- Adding a new service
- Adding a new method to a service
- Adding a field to a request message, as long as the service succeeds when the new field isn't set by older clients
- Adding a field to a response message, which is deserialized into the response message's unknown fields collection if an older client hasn't been updated
- Adding a value to an enum, as long as older clients run correctly when receiving the new enum value
Policy
The gRPC versioning policy is designed to support services that change over time, allowing existing clients to continue working without changes. This is achieved through non-breaking changes, which are additions to gRPC services and methods that don't break existing clients.
Non-breaking changes are beneficial as they allow existing clients to continue running, avoid the work involved with notifying clients of breaking changes, and only require one version of the service to be documented and maintained.
Non-breaking changes at a gRPC protocol level and .NET binary level include adding a new service, adding a new method to a service, adding a field to a request message, adding a field to a response message, and adding a value to an enum.
Expand your knowledge: Current Version of Dropbox
Binary breaking changes, on the other hand, are non-breaking at a gRPC protocol level but require the client to be updated if it upgrades to the latest .proto contract or client .NET assembly. These changes include removing a field, renaming a message, nesting or unnesting a message, and changing the csharp_namespace.
Here are some specific examples of binary breaking changes:
Protocol breaking changes are those that break the gRPC protocol and binary compatibility. These include renaming a field, changing a field data type, changing a field number, renaming a package, service, or method, and removing a service or method.
If this caught your attention, see: C# Grpc Service
Upgrading Dependencies
When upgrading your dependencies, it's essential to use a Bill of Materials (BOM) to ensure a smooth transition.
Using a BOM helps you manage dependencies and avoid version conflicts.
For example, if you're upgrading spring-boot, it's recommended to do so using a BOM that includes spring-boot and grpc-java.
Similarly, if you're upgrading grpc-spring-boot-starter, the recommended BOM includes grpc-spring-boot-starter, spring-boot, and grpc-java.
On a similar theme: Spring Grpc
gRPC Services and Policy
Services should strive to remain backwards compatible with old clients. This means avoiding breaking changes if possible.
To maintain backwards compatibility while making breaking changes, you can publish multiple versions of a service. gRPC supports an optional package specifier, which can be used to specify a version number for your service and its messages.
A service address allows multiple versions of a service to be hosted side-by-side. For example, greet.v1.Greetergreet.v2.Greeter are two different service addresses.
When planning to publish multiple versions of a service, follow these best practices: Avoid breaking changes if reasonable.Don't update the version number unless making breaking changes.Do update the version number when you make breaking changes.
Explore further: When to Use Grpc
Services
Services are a crucial part of gRPC, and it's essential to understand how to manage them effectively.
Services should strive to remain backwards compatible with old clients.
Breaking old clients and forcing them to be updated along with your service isn't a good user experience.
You might enjoy: Terabox Old Version
A way to maintain backwards compatibility while making breaking changes is to publish multiple versions of a service.
gRPC supports an optional package specifier, which functions much like a .NET namespace.
The package will be used as the .NET namespace for generated .NET types if option csharp_namespace is not set in the .proto file.
The package can be used to specify a version number for your service and its messages.
A service address allows multiple versions of a service to be hosted side-by-side:
- greet.v1.Greeter
- greet.v2.Greeter
Implementations of the versioned service are registered in Startup.cs.
Including a version number in the package name gives you the opportunity to publish a v2 version of your service with breaking changes, while continuing to support older clients who call the v1 version.
Once clients have updated to use the v2 service, you can choose to remove the old version.
When planning to publish multiple versions of a service:
- Avoid breaking changes if reasonable.
- Don't update the version number unless making breaking changes.
- Do update the version number when you make breaking changes.
What Is gRPC Policy?
gRPC versioning policy is clearly outlined online.
The gRPC versioning policy can be found by visiting the specified link.
gRPC Version Comparison
The gRPC versioning policy is available for reference, so you can check it out if you're curious.
gRPC changes its API frequently, so it's essential to report any issues to the repo if you encounter problems.
In most cases, you can upgrade to newer versions, but it's crucial to stick to the documented version if you're using the non-shaded netty and related libraries.
Table
The table provided by the library is a great resource for understanding the spring and gRPC versions it ships with. You can upgrade to newer versions, but be aware that gRPC changes its API frequently.
It's a good idea to report any issues to the repository, as the developers can help you troubleshoot. This will ensure that your problem gets addressed quickly.
The table also warns against using non-shaded netty and related libraries, as they require precise versioning. This is because gRPC's API changes often, and using the wrong version can lead to issues.
If you're using non-shaded netty, stick to the version documented by gRPC. This will help you avoid compatibility problems.
Broaden your view: Azure Api Version
When Do Happen?
gRPC releases happen every 6 weeks on a best effort basis, which means they might not always stick to this schedule but aim to do so.
The tip of the master branch is always stable, which is a key part of the project's release model.
This stable nature of the master branch allows for checkpoint releases to be shipped regularly, giving developers a consistent and reliable framework to work with.
gRPC Version Specifics
gRPC versioning policy is not explicitly stated in the provided examples, but it can be inferred that versioning follows a specific pattern, with each release having a unique version number, such as v1.74.0.
Each release includes a list of changes, with some releases focusing on specific areas, like OTel C++ and Posix EE in v1.74.0, or event_engine in v1.72.2.
Protocol breaking changes can occur due to various reasons, including renaming a field, changing a field data type, changing a field number, renaming a package, service, or method, and removing a service or method.
v1.76.0-Pre1
The prerelease of gRPC Core v1.76.0 contains refinements, improvements, and bug fixes. This prerelease is a genuine version of the upcoming v1.76.0 release.
The prerelease is a great opportunity to test and provide feedback on the new features and bug fixes before the official release. This will help ensure that the final version is stable and meets the needs of users.
One of the bug fixes in this prerelease addresses an issue with gRPC Python Client not reconnecting in certain situations. This issue was previously fixed in v1.74.0 and v1.71.2, but the fix has now been backported to this prerelease.
Here are some of the key features and bug fixes in this prerelease:
- gRPC Python (grpcio) now depends on typing-extensions~=4.13.
- Update musllinux wheels from musllinux_1_1 to musllinux_1_2.
- grpc.aio typehint fixes.
- Fixes issue with grpcio failing to install on all non-Mac Apple devices internal builds.
Overall, this prerelease is a significant step towards the final release of v1.76.0, and it's essential to test and provide feedback on these new features and bug fixes.
Binary Breaking Changes
Binary breaking changes can occur without affecting the gRPC protocol level, but they do require updating the client if you upgrade to the latest .proto contract or client .NET assembly.
For another approach, see: Grpc New Client
If you remove a field from a message, its values will be deserialized to the message's unknown fields, so it's essential to specify deleted field numbers and names on the message using Protobuf's reserved keyword to avoid reusing the field number in the future.
Renaming a message isn't a gRPC protocol breaking change, but the client will need to be updated if it upgrades to the latest contract, especially when message names are sent on the network with Any fields.
Changing the nesting or unnesting of a message can have the same impact on compatibility as renaming, since it changes the message name.
Changing the csharp_namespace will change the namespace of generated .NET types, requiring the client to be updated if it upgrades to the latest contract.
Here are some specific changes to be aware of:
- Removing a field: Specify deleted field numbers and names on the message using Protobuf's reserved keyword.
- Renaming a message: Update the client if it upgrades to the latest contract, especially when message names are sent on the network with Any fields.
- Nesting or unnesting a message: Change the message name, requiring the client to be updated.
- Changing csharp_namespace: Update the client if it upgrades to the latest contract.
Supported Duration
gRPC releases are supported for a limited duration. The project doesn't do LTS releases, which means you won't find long-term support for specific versions.
The rolling release model is used, where the current and previous releases are supported. This means you can expect bug fixes and security fixes for these two releases.
Support is limited to the current and previous releases, so if you're on an older version, you might be out of luck.
Readers also liked: Onedrive Restore Previous Version
Python
Python has some notable updates in gRPC. The release of grpcio wheels now supports Python 3.14.
One of the key fixes is for a grpc shutdown race condition that occurred during python interpreter finalizations. This issue has been resolved in version #40447.
gRPC has preserved the current behavior when using grpc.aio async methods outside of a running event loop in Python 3.14. This is thanks to the fix implemented in version #40750.
Here's a quick rundown of the Python updates:
- Release grpcio wheels with Python 3.14 support (#40403)
- Asyncio: fixes grpc shutdown race condition occurring during python interpreter finalizations. (#40447)
- Python 3.14: preserve current behavior when using grpc.aio async methods outside of a running event loop. (#40750)
Frequently Asked Questions
Is gRPC using HTTP2?
Yes, gRPC is specifically designed for HTTP/2, leveraging its performance benefits through binary framing and compression. This compact and efficient protocol enables faster data transfer.
Featured Images: pexels.com
