The document discusses implementing health checks and dependency injection in .NET Core applications, emphasizing the importance of monitoring the health status of services for system reliability. It details how to set up health checks using various tools and protocols, as well as best practices for ensuring that services can effectively report their health status. Additionally, it covers advanced dependency injection techniques and configuration options to integrate these health monitoring solutions into .NET Core applications.

1. Using dependency injection and
health checks in your
.NET Core solutions
Alex Thissen
Cloud architect at Xpirit, The Netherlands

2. Keeping entire system running
Determine state of entire system and intervene
How to know health status of individual services?
Collecting/correlating performance and health data
Sentry.ioRaygun.io RunscopeNewRelic AlertSite DataDogAppMetrics Azure Monitor

3. Centralized
Challenging
Doctor, am I sick? 12:34
Let's look at your vitals we
measured earlier:
- Pulse 60 per minute
- Blood pressure 130/80
12:34
Looks fine to me.
It seems you are healthy. 12:35
Thanks, doctor! 12:36
Let's look at your vitals we
measured:
- Pulse 180 per minute
- Blood pressure 150/110
12:34
Does not look good.
It seems you are unhealthy. 12:35

4. Modern medicine and health
Self-assessment
Context matters
You know best
Let's see. My vitals say:
- Pulse 180 per minute
- Blood pressure 150/110 12:34
How are you doing today?
12:36
Does not look good.
It seems I am unhealthy. 12:34
Oops, we need to do
something about that! 3:24
Good to know.
Stay healthy! 12:36
It's okay, as I am working out now
My back does not hurt.
So, I'm healthy!
12:34

5. Difference between metrics and health info
Metrics
Many individual measured values and counts
of events
Watch performance and trends
Useful for diagnostics and troubleshooting
Logic external to origin
Health
Intrinsic knowledge of implementation
required
DevOps mindset:
Logic to determine health is part of origin
Deployed together, good for autonomy

6. Availability
Latency
Internals
Simple Advanced
External dependencies
Readiness & liveliness
Preventive
Predicting
Examples

7. Healthy
• 200 OK
• "Everything is fine"
Degraded
• 200 OK
• "Could be doing
better or about to
become unhealthy"
Unhealthy
• 503 Service
Unavailable
• "Not able to perform"

8. ASP.NET Core application
/api/v1/… Middle
ware
New in .NET Core 2.2
Bootstrap health checks in
ASP.NET Core app
services.AddHealthChecks();
endpoints.MapHealthChecks("/health);
/health DefaultHealthCheckService
Microsoft.Extensions.Diagnostics.HealthChecks
.Abstractions
.EntityFramework
Microsoft.AspNetCore.Diagnostics.HealthChecks

9. What?
When?
How?
When a service is
unhealthy, how can you
trust its health status?public interface IHealthCheck
{
Task<HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = default);
}
From: https://github.com/aspnet/Diagnostics/blob/master/src/
Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions/HealthReport.cs

10. services
.AddHealthChecks()
.AddCheck("sync", () => … )
.AddAsyncCheck("async", async () => … )
.AddCheck<SqlConnectionHealthCheck>("SQL")
.AddCheck<UrlHealthCheck>("URL");
ASP.NET Core application
/health
DefaultHealthCheckService

11. Demo
ASP.NET Core 3.0 Health
object model
Health checks
Endpoints

12. Only 1 out-of-box check
DbContext
Build your own
IHealthCheck
Community packages
Xabaril/BeatPulse
Yours?AspNetCore.Diagnostics.HealthChecks.*
Microsoft.Extensions.Diagnostics.
HealthChecks.EntityFrameworkCore
services.AddHealthChecks()
.AddDbContextCheck<GamingDbContext>("EF")

13. Register multiple health endpoints
Middleware options
Register custom health check as singleton
/api/v1/…
/health
/ping
services.AddSingleton<KafkaHealthCheck>());
services.AddSingleton(new SqlConnectionHealthCheck(
new SqlConnection(Configuration.GetConnectionString("TestDB"))));

14. 1. Customize health endpoint output for more details
2. Query endpoint(s)
3. Build user interface

15. Demo
A bit more advanced

16. Endpoints Frequency Locations Alerts

17. Pushes out health
info periodically
Options
ASP.NET Core application
DefaultHealthCheckService
HealthCheckPublisher
HostedService
IEnumerable<IHealthCheckPublisher>
services.AddHealthChecks()
.AddApplicationInsightsPublisher()
.AddPrometheusGatewayPublisher(
"http://pushgateway:9091/metrics",
"pushgateway") IHealthCheckPublisher

18. Registering a HealthCheckPublisher pre-.NET Core 3.0
// The following workaround permits adding an IHealthCheckPublisher
// instance to the service container when one or more other hosted
// services have already been added to the app. This workaround
// won't be required with the release of ASP.NET Core 3.0. For more
// information, see: https://github.com/aspnet/Extensions/issues/639.
services.TryAddEnumerable(
ServiceDescriptor.Singleton(typeof(IHostedService),
typeof(HealthCheckPublisherOptions).Assembly
.GetType(HealthCheckServiceAssembly)));

19. PrometheusGrafana
.NET Core app
Push
gateway
HealthCheckPublisher
HostedServiceNotification
channel
 Slack
 Telegram
 VictorOps
 PagerDuty
 …

20. Demo: Publishers
Prometheus and Grafana

21. Performance
MonitoringAvailability
Resiliency

22. Probing containers to check for availability and health
Kubernetes node
Kubernetes node
Kubernetes nodes
Containers
Readiness
Liveliness

23. 1. Add health checks with tags
2. Register multiple endpoints
with filter using
Options predicate
/api/v1/…
/health
/health/ready
/health/lively
app.UseHealthChecks("/health/ready",
new HealthCheckOptions() {
Predicate = reg => reg.Tags.Contains("ready")
});
services.AddHealthChecks()
.AddCheck<CircuitBreakerHealthCheck>(
"circuitbreakers",
tags: new string[] { "ready" });
app.UseHealthChecks("/health/lively",
new HealthCheckOptions() {
Predicate = _ => true
});

24. Original pods only taken offline after new healthy one is up
Allows roll forward upgrades: Never roll back to previous version

25. Demo
Readiness and liveness
probes
Docker containers
Kubernetes

26. Expose as little detail as possible
Use different internal port
Add authentication using
middleware
Publish instead of endpoint
app.UseWhen(
ctx => ctx.User.Identity.IsAuthenticated,
a => a.UseHealthChecks("/securehealth")
);

27. 1. Assume degraded state
2. Set short timeouts on checks
3. Avoid complicated health checks
4. Register health check as singletons in DI

28. /api/v1/…
/health
/ping

29. 1. Unit testing
2. SOLID: Dependency
Inversion Principle
3. Loose coupling
4. Clean architecture
5. .NET Core is using it
Related
Domain
Logic
Presentation
From Jason Taylor: Clean Architecture with ASP.NET Core 2.2

30. Container HomeController
FloppyDiskRepository
IRepository
ILogger
ConsoleLogger

31. Possible ways to map
Try Add<ServiceType ImplementationType>
Builder pattern
Add TryAdd
ServiceType ImplementationType

32. Demo: ASP.NET Core DI
Quick look at how you were using
dependency injection all along

33. Register
• How
• Add… and TryAdd… of
type mappings
• Add… extension
methods
• Where
• Application root
• Startup class (ASP.NET)
Resolve
• Implicit
• Constructor injection
• ASP.NET Core specifics
• Explicit
• GetService<T>
• GetRequiredService<T>
• Also for enumerables
Release
• Automatic
• Resolved instances and
dependencies
• Scopes
• End of scope
• Might need to create
child scopes
IServiceCollection IServiceProvider IDisposable
1 2 3

34. Singleton
• Easy way to
implement
singleton pattern
• One instance per
DI container
• Beware of
concurrency and
threading issues
Scoped
• Duration of scope
• ASP.NET uses web request as scope
• Useful for UnitOfWork objects,
e.g. DbContext
• See also ServiceScopeFactory
Transient
• Single use
• Most common and safest

35. Typical startup in ASP.NET Core
public class Startup
{
public Startup(IConfiguration configuration, IHostEnvironment env)
public void ConfigureServices(IServiceCollection services)
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, …)
}
builder.UseStartup<Startup>();
1
2
3

36. Many ways to inject a
service instance
IServiceProvider
Pro tip
ActivatorUtilities
IServiceProvider
Register using
Configure(Services)
injection in Startup
class
Constructor
injection
[FromServices]
attribute
@inject
IApplicationBuilder.
ApplicationServices
HttpContext.
RequestServices
Middleware
Constructor or
Invoke method

37. Demo: Resolving services
in ASP.NET Core
Controller constructors
@inject
FromServicesAttribute
Application- and RequestServices

38. Hosting outside
and without ASP.NET Core
IHostedService
BackgroundService
Uses new Host, and
IHostBuilder for hosting
Startup
WebHostBuilder
HostBuilder Configure
Microsoft.Extensions.Hosting
Microsoft.Extensions.DependencyInjection

39. Resolved instances are released at end of scope
IDisposable Dispose
Create your own scopes with ServiceScopeFactory
Especially important for hosted services
AddHostedService<T>
using (var scope = serviceScopeFactory.CreateScope()) {
ISomeRepository scoped =
scope.ServiceProvider.GetRequiredService<ISomeRepository>();
await DoMyWork(scoped);
}

40. Check lifetime restrictions
Prevent memory leaks
and unexpected behavior
Host.CreateDefaultBuilder(args)
.UseDefaultServiceProvider((context, options) => {
options.ValidateScopes =
context.HostingEnvironment.IsDevelopment();
options.ValidateOnBuild = true; // .NET Core 3.0
})

41. Demo: Generic Host
New .NET Core 3.0 hosting
Scope validation
Using scopes

42. Too much abstractions
Conforming container
Easy to use anti-patterns

43. Microsoft.Extension.DependencyInjection
DefaultServiceProviderFactoryDuring configuring
ServiceDescriptors
IServiceProviderFactory<T>
CreateServiceProvider
CreateBuilder
ContainerBuilder
Build
System.ComponentModel.IServiceProvider
LightInjectServiceProviderFactory
During runtime ServiceProvider
GetService<T>
LightInjectServiceProvider
GetService<T>
IServiceContainer
Build
IServiceProviderFactory<T>
CreateServiceProvider
CreateBuilder

44. Plug in your favorite DI Framework
Option 1: While building host
UseServiceProviderFactory
ConfigureContainer
Option 2: When configuring services
ConfigureServices
IServiceProvider
Some alternative
DI Frameworks
Autofac
Castle Windsor
Lamar
LightInject
Ninject
SimpleInjector
Spring.NET
Unity

45. Demo: Advanced DI
Replacing DI container
Custom DI containers

46. Different registrations for environments
Configure{Environment}Services
Configure{Environment}
Startup{Environment} StartupProduction
Requires different startup
UseStartup<Startup>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder => {
var assembly = typeof(Startup).GetTypeInfo().Assembly;
webBuilder.UseStartup(assemblyName.GetName().Name);
});

47. Demo: Tips and tricks
Convention based startup
TestServer services override

48. Avoid use Service Locator pattern
IServiceProvider
IServiceScopeFactory.CreateScope
Do not directly inject HttpContext
IHttpContextAccessor
accessor.HttpContext.RequestServices
Avoid complex lifetime graphs

49. Dependency injection is
integral part of
.NET Core
If you do not like it,
replace it

50. Questions and Answers

51. Resources
https://docs.microsoft.com/en-us/azure/architecture/patterns/health-endpoint-monitoring
https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks
https://github.com/aspnet/Diagnostics/tree/master/src
https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/
https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks
https://github.com/alexthissen/healthmonitoring