Create A Grafana Dashboard With .NET Core: A How-To Guide
Hey guys! Ever wanted to visualize your .NET Core application metrics in a slick, customizable dashboard? Well, you've come to the right place! This guide will walk you through creating Grafana dashboards using data from your .NET Core applications. We'll cover everything from setting up the basics to diving into advanced configurations. Let's get started!
Why Grafana and .NET Core?
Let's kick things off by understanding why this combination is a match made in heaven. Grafana is an open-source data visualization and monitoring tool that lets you create interactive dashboards. It supports a plethora of data sources, making it incredibly versatile. On the other hand, .NET Core is a powerful, cross-platform framework for building modern applications. By integrating the two, you can gain incredible insights into your application's performance and behavior.
The Power of Visualization
Data is the new gold, right? But raw data is like unmined gold—it's valuable, but you can't use it until you refine it. Grafana acts as your data refinery, transforming metrics and logs into insightful visualizations. Imagine being able to see your application's CPU usage, memory consumption, and request latency all in one place. That's the power of Grafana.
.NET Core's Monitoring Capabilities
.NET Core provides robust mechanisms for collecting metrics through libraries like System.Diagnostics.Metrics and Microsoft.Extensions.Diagnostics.HealthChecks. These tools allow you to expose valuable data points about your application, which Grafana can then consume and display. This synergy allows you to proactively monitor your application's health and performance, ensuring a smooth user experience. Using .NET Core's built-in diagnostic tools combined with Grafana's visualization prowess gives you a complete observability solution.
Setting Up Your Environment
Okay, enough talk about why this is cool; let's get our hands dirty! First, we need to set up our development environment. This involves installing the necessary tools and creating a basic .NET Core application.
Installing .NET Core SDK
If you haven't already, the first step is to install the .NET Core SDK. Head over to the official .NET download page and grab the appropriate installer for your operating system (Windows, macOS, or Linux). Follow the installation instructions, and you should be good to go. Once installed, you can verify the installation by opening a terminal or command prompt and running dotnet --version. You should see the version number printed out.
Creating a New .NET Core Project
Next, let's create a new .NET Core project. Open your terminal and navigate to the directory where you want to create your project. Then, run the following command:
dotnet new webapi -n MyWebApp
cd MyWebApp
This will create a new ASP.NET Core Web API project named MyWebApp. We're using a Web API project because it's a common scenario for exposing metrics, but you can adapt these steps to other types of .NET Core applications as well.
Installing Grafana and Prometheus
Grafana needs a data source to visualize, and for this guide, we'll use Prometheus, a popular open-source monitoring solution. Prometheus excels at collecting and storing time-series data, making it an excellent companion for Grafana.
Installing Grafana
You can install Grafana in several ways, including using Docker, downloading binaries, or using package managers. For simplicity, let's use Docker. If you don't have Docker installed, grab it from Docker's website. Once Docker is up and running, run the following command in your terminal:
docker run -d -p 3000:3000 --name=grafana grafana/grafana
This command downloads the Grafana Docker image and starts a Grafana instance, mapping port 3000 on your host to port 3000 in the container. You can then access Grafana by opening your web browser and navigating to http://localhost:3000. The default credentials are admin for both the username and password.
Installing Prometheus
Similarly, we can use Docker to run Prometheus. First, you'll need a Prometheus configuration file (prometheus.yml). Create a file named prometheus.yml in your project directory with the following content:
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'dotnet-metrics'
static_configs:
- targets: ['localhost:5000'] # Adjust the port if needed
This configuration tells Prometheus to scrape metrics from localhost:5000 every 15 seconds. Now, run Prometheus using Docker:
docker run -d -p 9090:9090 --name=prometheus -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
This command mounts the prometheus.yml file into the container and starts Prometheus, mapping port 9090 on your host to port 9090 in the container. You can access the Prometheus UI by navigating to http://localhost:9090.
Exposing Metrics from Your .NET Core Application
Now that we have Grafana and Prometheus set up, let's focus on exposing metrics from your .NET Core application. We'll use the System.Diagnostics.Metrics API for this.
Adding Necessary NuGet Packages
First, add the prometheus-net.AspNetCore NuGet package to your project. This package provides middleware for exposing metrics in Prometheus format. Run the following command in your terminal:
dotnet add package prometheus-net.AspNetCore
Instrumenting Your Code
Next, let's add some instrumentation to your code. Open your Program.cs file and modify it as follows:
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using Prometheus;
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
webBuilder.UseKestrel(options =>
{
options.ListenAnyIP(5000);
});
});
}
Then, open your Startup.cs file and modify the Configure method:
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Prometheus;
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseHttpMetrics(); // Add this line
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapMetrics(); // Add this line
});
}
}
We've added UseHttpMetrics() and MapMetrics() to the pipeline. UseHttpMetrics() exposes metrics about HTTP requests, and MapMetrics() exposes the metrics endpoint at /metrics.
Creating Custom Metrics
Exposing built-in metrics is great, but what if you want to track custom metrics specific to your application? Let's create a simple example. Open your Controllers/WeatherForecastController.cs file and add the following code:
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Prometheus;
using System;
using System.Collections.Generic;
using System.Linq;
namespace MyWebApp.Controllers
{
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
private static readonly string[] Summaries = new[]
{
"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};
private readonly ILogger<WeatherForecastController> _logger;
private static readonly Counter ForecastsRequested = Metrics.CreateCounter("forecasts_requested_total", "Number of weather forecast requests.");
public WeatherForecastController(ILogger<WeatherForecastController> logger)
{
_logger = logger;
}
[HttpGet]
public IEnumerable<WeatherForecast> Get()
{
ForecastsRequested.Inc();
var rng = new Random();
return Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray();
}
}
}
We've added a Counter metric named forecasts_requested_total that increments each time the Get method is called. This is a simple example, but you can use similar techniques to track other application-specific metrics.
Running Your Application
Now, let's run your application. In your terminal, run the following command:
dotnet run
Your application should start, and you can access it by navigating to http://localhost:5000 in your web browser. To see the exposed metrics, navigate to http://localhost:5000/metrics. You should see a wall of text in Prometheus's exposition format, including the forecasts_requested_total metric.
Configuring Prometheus to Scrape Metrics
Remember the prometheus.yml file we created earlier? It's time to configure Prometheus to scrape metrics from your application. Open the file and ensure the targets setting points to your application's metrics endpoint. In our case, it should be localhost:5000. If you've changed the port your application is listening on, adjust the setting accordingly.
Restart the Prometheus container to apply the changes:
docker stop prometheus
docker rm prometheus
docker run -d -p 9090:9090 --name=prometheus -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
After restarting, Prometheus should start scraping metrics from your application. You can verify this by navigating to the Prometheus UI (http://localhost:9090), clicking on the
