Workshop: Modern .NET-Backends for Angular

Flexible Backends for Your Angular Solutions

In this intensive training, you will learn how modern and optimized backends can be developed for an Angular application. During the training, in addition to developing the backend, you will also develop the logic required for communication with the backend within the Angular application yourself.

This way you will learn how to integrate your backend with concepts from Domain Driven Designs and Microservices. You will find out what needs to be considered for good communication via HTTP and what level 4 REST services are actually all about.

In addition, during the training, you will be shown HATEOAS (Hypermedia As The Engine Of Application State) as another alternative for state management within your application. Also, topics such as data access, authentication, and authorization are also examined in more detail during the training.

During the exercises, you create a backend for an Angular application, which you can use later as a template for your own applications.

Highlights:

  • ✅ Building WebAPIs with ASP.NET Core and accessing relational databases with Entity Framework Core
  • ✅ Decomposition of the backend into microservices and APIs using Domain-Driven Design
  • ✅ Access to the backend via an API Gateway / BFF (backend for frontend)
  • ✅ State Management via HATEOAS and Level 4 REST Services
  • ✅ Optimal and high-performance access to the backend from the Angular application
  • ✅ Authentication and authorization
  • ✅ Bonus: Hosting using container technologies

Microservices with ASP.NET Core

Right at the beginning of the training, we develop a microservice using ASP.NET Core. The resulting microservice serves as the basis for the further chapters and will be constantly expanded from now on.

We assume that you already have experience in developing with .NET (Core) and know the programming language C#.

The following aspects are examined in detail:

  • Basics of ASP.NET for Web APIs
  • Dependency injection
  • Logging
  • Configuration
  • Filters

Data Access with Entity Framework Core

Almost every application works with data and has to persist it. Therefore,  in the next step, we will show working with relational data. We extend our microservice from the first chapter with a relational database that we access using Entity Framework Core.

The following aspects are examined in detail:

  • Entity Framework Core basics (Create, Read, Update, Delete)
  • Migrations
  • Entity Properties
  • Relationships

Robust Web APIs

This part of the training is all about the HTTP protocol. Without detailed knowledge of how it works, you will not be able to build good web APIs. Therefore, in this part, topics like URLs, headers, status codes, and the resource model of HTTP are addressed in particular.

It is also shown how using Domain-Driven Design can slice a Web API into individual endpoints. Finally, we refactor the previously created microservice to apply the principles of HTTP and Domain-Driven Design (DDD) in the best possible way. Also, you see how Data Transfer Objects (DTOs) can be used.

The following aspects are examined in detail:

  • Get to know HTTP as a transmission protocol
  • What we can learn from Domain Driven Design for designing Web APIs
  • Providing optimized REST endpoints for Create, Read, Update and delete operations
  • Data Transfer Objects and POCOs

Microservices and API Gateways / Backend for Frontends (BFF)

In this chapter of the training, the participants receive another microservice. For accessing both micro frontends in an efficient way, an API Gateway implemented using ASP.NET is used. In addition, it is examined in more detail how microservices can be divided into categories and structured.

At the end of this section, the trainer provides an Angular frontend in which the calls to the microservices are implemented via an API gateway. Thus, for the first time, a complete end-to-end example is created.

The following aspects are examined in detail:

  • Basics of a microservice architecture
  • Principles for structuring and accessing a larger number of microservices
  • Using dynamic data structures or OpenAPI Swagger to call a microservice
  • Calling microservices from the frontend via an API gateway / BFF

State Management via HATEOAS

HATEOAS stands for Hypermedia as The Engine of Application State and is a paradigm that helps us to control the application state of the entire system centrally from the backend. If implemented correctly, you can even change the behavior of the Angular client without having to distribute an update for it.

This paradigm is particularly useful for client applications that usually have a connection to the backend (such as in-house enterprise applications). The client focuses in particular on presentation and user interaction. Central application logic takes place exclusively in the backend.

In this chapter, another API gateway is created according to the HATEOAS principles and called from another Angular application.

The following aspects are examined in detail:

  • Basics and possibilities of state management in a distributed application
  • RESTful Web APIs and Hypermedia
  • Building JSON-based Hypermedia in ASP.NET Core
  • Using a HATEOAS backend from an Angular application

Asynchronous Communication and Messaging

Microservices should be as independent as possible. If they still have to exchange data, this should not be done using direct calls as this would tightly couple the microservices to each other.

Instead, one should use asynchronous communication. With Web Sockets, there is even the ability to asynchronously send messages from backend to frontend. This part of the workshop
shows how an event from a microservice can be sent via asynchronous and event-based communication up to Frontend.

The following aspects are examined in detail:

  • Introduction to Asynchronous Communication
  • Using Web Sockets with SignalR in ASP.NET Core and in Angular
  • Using RabbitMQ to implement Publish/Subscribe

Authentication and Authorization

Another common application requirement is the ability to identify who is using the Application work and whether it is allowed to work with the requested data/functions.

Therefore, in the next step, we will add authentication and authorization to our application. We learn how an identity service can be integrated into the user system to implement authentication and authorization using OAuth2 and OpenId Connect.

The following aspects are examined in detail:

  • OAuth2 and OpenId Connect as modern authentication protocols
  • JSON Web Tokens (JWT) as containers for OAuht2 and OpenId Connect information
  • Integration of a security token service

Bonus: Hosting using Container Technologies

After developing two Angular applications and an associated backend, we will deploy both via Docker containers.

If everything runs with Docker locally, we are also prepared to take the step into the cloud.

The following aspects are examined in detail:

  • Hosting an Angular application inside a Docker container using nginx as web server
  • Hosting ASP.NET Web APIs inside a Docker container
  • Use Docker Compose to run the entire system locally
  • Challenges when debugging a containerized system

Public Workshops

Always By arrangement

All of our seminars are always available remotely or in-house. Contact us to make an appointment

Remote or In-House

The trainer has incredible knowledge of Angular and beyond and explains very understandably."

Participant in June 2019, Vienna

Only One Step Away!

Send us your inquery today - we help you with pleasure!

Jetzt anfragen!