Irina Scurtu
Microsoft MVP, Software Architect
Iaşi, Romania
Microsoft MVP for Developer Technologies, Software Architect and Microsoft Certified Trainer, always in a quest for latest trends and best practices in architecture, .NET and the world around it.
Irina has more than 1000 hours of delivered trainings, workshops, and presentations, being passionate about .NET and the world around it.
She is the founder of DotNet Iasi User Group where she tries to gather people that are willing to share their knowledge with others, and from time to time publishes articles on her blog: http://irina.codes
Links
Awards
Area of Expertise
Topics
.NET gRPC - deep dive
With an increasing need for scalability and performance dictated by the modern web, it becomes harder and harder to choose an API paradigm that is suitable for service-to-service communication.
While the classical models still work and have their own merits, some of them rely heavily on documentation, extensive coordination between teams or code-sharing. We use shared libraries, and over time our projects become intertwined with dependencies. In these cases, we need something to untangle those and reduce coupling. Welcome gRPC.
gRPC has been around for a while and .NET Core 3.0 welcomes it as a first-class citizen. It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server to bi-directional streaming out of the box.
If we sprinkle some client-side load balancing and the ability of exposing a gRPC service also as a HTTP API we might the perfect point-to-point communication mechanism.
In this session, we will deep-dive in how to use gRPC, configure client-side load balancing and gRPC transcoding to streamline communication.
Communication in a microservice world
Microservices should be autonomous and independent, but what happens when your business domain doesn’t allow it, and you need to get data from other microservices? You’ll soon realize that simple HTTP calls are not enough anymore, or that your app is more brittle than ever and then you switch to messaging. With messaging you need to have a different mindset and be willing to embrace new challenges.
In this session we’ll explore different ways of getting data from one ‘micro-service’ to another and while doing that we’ll talk about the benefits or the drawbacks of choosing an approach or another.
REST - the ignored parts
In a world dominated by APIs, where everyone seems to implement microservices with so many paradigms and stadards to choose from, REST seems to be the default option.
Despite that, many of these so-called REST APIs have a littele to do with what REST should be, and are often brittle because we ignore some of the most powerful constraints.
We ignore HATEOAS, under the pretext that will add a performance penalty, or because we don't see the imediate benefit from it. When it comes to versioning, we prefer to
version by having the version in the URL path, and sometimes we never change the version.
We are pressured to deliver, to meet the deadlines
and this leads sometimes to poor desing. We choose a few HTTP Verbs and status codes that are all purpose, and that's it.
In reality, REST is not only about verbs and namings, is also about meaning, empaty towards our API consumers, longevity
and leveraging everything that the underlying protocol has to offer.
In this session we will look over how we can design a REST API that is flexible and evolvable by being in sync with what
HTTP has to offer.
We will look over OData as a way to filter data, versioning, hypermedia types specs and status codes by fine-tuning .NET Core.
Embracing gRPC in .NET
With an increasing need for scalability and performance dictated by the modern web, it becomes harder and harder to choose an API paradigm that is suitable for service to service communication.
While the classical models still work and have their own merits, some of them rely heavily on documentation, extensive coordination between teams or code-sharing. We use shared libraries, and over time our projects become intertwined with dependencies. In these cases, we need something to untangle those and reduce coupling. Welcome gRPC.
gRPC has been around for a while and .NET Core 3.0 welcomes it as a first-class citizen. It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server, to bi-directional streaming out of the box.
In this session, we will look at how to use gRPC and its 4 models and what are the benefits and or downsides of using gRPC compared to the traditional models.
Junior/Mid developers or developers that never used gRPC.
It will be the first public delivery of this. 50 mins
1 day Workshop -From RESTful API to gRPC
gRPC has been around for a while now, but never gained the first-class citizen title when it came to implementing a downstream API.
It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server to bi-directional streaming out of the box. If we sprinkle some client-side load balancing, transient fault-handling and the ability of exposing a gRPC service also as a HTTP API, we might the perfect point-to-point communication mechanism.
In this 1 day workshop you will learn the how and the whys and understand where gRPC fits in the .NET APIs ecosystem.
Topics covered:
- What gRPC is and how it fits in an API context
- working with proto files, most common scenarios
- the 4 gRPC types
- Implementing and consuming gRPC services
- Documenting and exposing gRPC endpoints
- Client-side load balancing
- gRPC transcoding
- transient fault-handling
Prerequisites
Attendees will require a laptop with the latest version on .NET SDK and their editor/IDE of choice:
- Visuals Studio 2022
- VS Code
2 Days workshop - From RESTful API to gRPC
It is contract-based, performant - with smaller response/request bodies, perfect for polyglot environments and supports different models – from client-server to bi-directional streaming out of the box. If we sprinkle some client-side load balancing, transient fault-handling and the ability of exposing a gRPC service also as a HTTP API, we might the perfect point-to-point communication mechanism.
In this workshop you will learn the how and the whys and understand where gRPC fits in the .NET APIs ecosystem. At the end of the workshop you will be able to use gRPC in real production environments.
Topics covered:
Introduction
- What gRPC is and how it fits in an API context
- gRPC vs RESTful APIs
- gRPC vs WCF
Protocol Buffers
- working with .proto files
- understanding the syntax
- defining custom types
Working with gRPC
- the 4 gRPC modes
- Implementing and consuming gRPC services
- Documenting and exposing gRPC endpoints
gRPC internals
- Accessing the gRPC context
- Accessing the gRPC HTTP context
- Trailers
- Headers
- Status codes in gRPC
- Exceptions in gRPC
Transient fault-handling
- Defining policies
- Configuring a retry policy
- Configuring a hedging policy
Interceptors
- Client interceptors
- Server interceptors
- Configuring interceptors
- Interceptors vs Middleware
Client-side load balancing
- implementing a client-side load balancing
- Configuring client-side load balancing
- load balancing policies
- Round-Robin
- Pick first
- Implementing our own policy
Transcoding
- what is is gRPC transcoding
- exposing our services as HTTP
- Consuming methods from the browser
- How routing works with gRPC transcoding
- gRPC JSON transcoding vs gRPC-Web
- grpc-gateway - alternative to transcoding
Testing
- Testing with Postman
- Unit testing service operations
Health-checks
- Implementing health checks
Securing gRPC services
Documenting gRPC endpoints
Prerequisites
Attendees will require a laptop with the latest version on .NET SDK and their editor/IDE of choice: Visuals Studio 2022
Contract Testing Made Easy: Mastering Pact for Microservices in C#
In a forever evolving world of microservices, with so many moving parts, we often rely on integration type of testing to prevent bugs and regressions.
The problem with these tests is that sometimes they become flaky, unreliable and expensive to maintain and execute, due to the distributed nature of our system.
But what if we could ensure that our system’s components are compatible and can communicate with each other straight from the development phase?
Let’s have a look at what Contract testing is and see how it can help us mitigate the risk of integration bugs before running long tests, with examples in C#.
Swetugg Stockholm 2024 Sessionize Event
DevReach 2023 Sessionize Event
Copenhagen Developers Festival 2023 Sessionize Event
NDC Oslo 2023 Sessionize Event
Techorama 2023 Belgium Sessionize Event
Swetugg Stockholm 2023 Sessionize Event
NDC London 2023 Sessionize Event
.NET Conf 2022 Sessionize Event
NDC Oslo 2022 Sessionize Event
NDC Porto 2022 Sessionize Event
Techorama 2021 Spring Edition Sessionize Event
JetBrains .NET Days Online 2021 Sessionize Event
NDC London 2021 Sessionize Event
Update Now 2020 Sessionize Event
.NET DeveloperDays 2020 Sessionize Event
Tech Con '20 Sessionize Event
.NET Core Summer Event 2020 Sessionize Event
NDC Porto 2020 Sessionize Event
Swetugg 2020 Sessionize Event
NDC London 2020 Sessionize Event
ProgNET London
RigaDevDays 2019
Everyone wants to avoid the big, bad, ugly monoliths and work with “Microservices” – these awesome, world-changing, independent “micro” puzzle pieces. You can distribute the load, you can scale better, you control everything and then you fail. And then you want the monolith back. And fail again.
Microservices should be autonomous and independent, but what happens when your business domain doesn’t allow it, and you need to get data from other microservices? You’ll soon realize that simple HTTP calls are not enough anymore, or that your app is more brittle than ever and then you switch to messaging. With messaging you need to have a different mindset and be willing to embrace new challenges.
In this session we’ll explore different ways of getting data from one ‘micro-service’ to another and while doing that we’ll talk about the benefits or the drawbacks of choosing an approach or another.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top