In this workshop, we will design an API with respect to the non-functional requirements that are paramount to any serious application running in production. For this, we will use .NET 8.

We will cover the design process of several API types, including REST, gRPC, GraphQL & OData. We will then transition towards messaging, always with an eye on the Cloud.

By the end of the workshop, you will know how to enforce architectural decisions and what it means to have an API that is evolvable, reliable and ready to scale.

Workshop Structure & Contents
- Why API design matters
- How we address the NFRs

Part 1 - Introduction to API design
We will cover:
- Guiding principles for API design
- Modular design
- What makes a good API

Part 2 - Types of APIs

Desiging REST - based APIs
In this section we delve into intricacies of REST-based APIs, the client/server nature of it and we explore the decision-making process behind choosing REST, by offering a detailed guide to the API design process, documenting and the most common usage scenarios.
- Http methods
- Http status codes
- Http headers
- Endpoint naming
- Media-type selection, design & custom media types
- Caching & Conditional caching
- Input & Output formatters
- Generating clients with SwaggerGen

Designing gRPC APIs
This section we cover gRPC and we outline the RPC API design process. We start by exposing and defining operations, particularities of consuming these APIs and document them. This succinctly summarizes the key components covered in this part, providing an overview of the gRPC protocol, considerations for RPC, and the step-by-step process for designing RPC APIs.

Designing Query-based APIs
In this section we cover the concept of a Query-Based API and we explore OData and GraphQL

Messaging-based APIs
In this section we learn the messaging fundamentals and we deep dive into a new world that covers queues, topics, message brokers and different tools. While we are here we will have a look at what AWS and Azure has to offer in order to understand what to use.

Part 3 - Addressing non-functional requirements
- What are NFRs and why should we care?
- Designing for change
- Reliability
- Performance, Optimization and Scalability
- Observability
- Documenting the APIs
- Testing the APIs
- Protecting the API
- Maintainability

Part 5 - APIs and Microservices
- Difference between APIs and microservices.
- Challenges
- Evolutionary architectures

Part 6 - From Monolith to Microservices
- Moving from a monolith to a microservice architecture
- Identifying business capabilities
- Balance and quality attributes
- Tradeoffs

Target audience and prerequisites
The workshop targets .NET Software developers that want to have a more architecture-focused view over designing APIs or simply want to understand what are the communication patterns, and the best practices for APIs in distributed architectures.

At the end of this workshop you will be able to:
- Understand which APIs are best suited for which scenarios
- Understand are the non-functional requirements needed for APIs
- Design and build APIs that are ready for production
- Address the most important “ilities” of any API

Computer Setup
Please bring your laptop with the following installed:
-Visual studio or preffered IDE
-.NET 8 SDK
-SQL Server with SQL management studio (or a tool that can access databases) Or docker with a sql server image and RabbitMQ RabbitMQ