Raspberry Pi and.NET Aspire

Introduction

Using.NET with a Raspberry Pi opens up a world of possibilities for both hobbyists and professionals, combining the power of.NET with the flexibility of Raspberry Pi.

Deploying web applications on a Raspberry Pi using.NET 9.0 is a cost-effective solution for small-scale projects and personal use. The improved efficiency of.NET 9.0 ensures that even a compact device like the Raspberry Pi can host web services with minimal latency and optimal performance.

.NET Aspire is designed to simplify and streamline the development of cloud-native applications. It offers a curated set of tools, templates, and packages that encapsulate best practices, making it easier to create, deploy, and manage distributed applications. Its key features include orchestration, service discovery, and standardized integrations with common services.

Visual Studio 2022 (Community Edition)

is a free, powerful integrated development environment (IDE) tailored for individual developers, open-source projects, academic settings, and small teams. It offers a comprehensive suite of tools for coding, debugging, and deploying applications across various platforms, including web, desktop, mobile, and cloud.

.NET Aspire Application

After installation of the Aspire templates by running

dotnet new install Aspire.ProjectTemplates

a.NET Aspire Starter App can be created using Visual Studio 2022 or the command line.

The sample app includes a frontend Blazor app that communicates with a Minimal API project. The API project is used to provide fake weather data to the frontend. The frontend app is configured to use service discovery to connect to the API project.

The.NET Aspire project launches a dashboard, that can be used to monitor various parts of the application.

Whether deploying to a local development environment or a cloud platform,.NET Aspire provides a consistent and efficient experience, reducing the complexity traditionally associated with multi-service applications. This results in faster deployment times, fewer errors, and a more seamless transition from development to production, allowing developers to focus on delivering value rather than managing infrastructure.

Goal

The goal is to run a.NET Aspire application, showcasing the implementation and deployment of a backend service and a web frontend on a Raspberry Pi. The application should be accessible remotely using just a browser to connect to the Raspberry Pi. Since the.NET Aspire applications are typically developed locally, and deployed remotely in a containerized environment such as Azure or Kubernetes containers a simple deployment to the Raspberry Pi is not possible.

The steps outlined here show a simple solution to run the.NET Aspire orchestrator application and the associated server applications on the Raspberry Pi accessible from outside.

Development

For the local development and simplified use, the HTTPS support is not necessary. However, to run the Aspire application without HTTPS support some changes are necessary.

Application Host

In the AppHost launch settings file launchSettings.json add the following settings:

"ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true",
"DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS": "true",

The launch url port can be changed too:

"applicationUrl": "http://localhost:5000",

The complete launch settings for the application host are:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "DOTNET_ENVIRONMENT": "Development",
        "ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true",
        "DOTNET_DASHBOARD_UNSECURED_ALLOW_ANONYMOUS": "true",
        "DOTNET_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:19097",
        "DOTNET_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:20287"
      }
    }
  }
}

Backend Service

The launch settings for the backend service are modified by adding:

"ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"

The launch url port can be changed too:

"applicationUrl": "http://localhost:9081",

The complete launch settings for the backend service are now:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"
      },
      "dotnetRunMessages": true,
      "applicationUrl": "http://localhost:9081"
    }
  }
}

To allow the generated OpenApi document to refer to the correct server url, change in the Program.cs file:

builder.Services.AddOpenApi();

to use the customized endpoint.

builder.Services.AddOpenApi(options =>
{
  options.AddDocumentTransformer((document, context, cancellationToken) =>
  {
    var url = builder.Configuration["WeatherApiEndpoint"] ?? 
        throw new InvalidOperationException("WeatherApiEndpoint is not set");
    document.Servers = [ new() { Url = url } ];
    return Task.CompletedTask;
  });
});

The corresponding appsetting.json file is changed to:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "OpenApiEndpoint": "http://localhost:9081"
}

With the above changes the OpenApi UI (e.g. Scalar) works using the correct endpoint.

Web Frontend

The launch settings for the web frontend are modified by adding:

"ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"

The launch url port can be changed too:

"applicationUrl": "http://localhost:9091",

The complete launch settings for the backend service (launchSettings.json) are:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:9091",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"
      }
    }
  }
}

Also change the base url for the HttpClient to using the correct IP address in the Program.cs file:

builder.Services.AddHttpClient<WeatherApiClient>(client =>
{
  var url = builder.Configuration["WeatherApiEndpoint"] ?? 
            throw new InvalidOperationException("WeatherApiEndpoint is not set");
  client.BaseAddress = new(url);
});

The corresponding appsetting.json file is changed to:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "WeatherApiEndpoint": "http://localhost:9081"
}

All those changes allow to run the Aspire host application (and services) without using HTTPS.

Raspberry Pi

On the Raspberry PI, first the.NET SDK has to be installed. Installing the.NET SDK on a Raspberry Pi involves a few straightforward steps to get your device ready for development. First, ensure your Raspberry Pi is up to date by running

sudo apt update

and

sudo apt upgrade

Next, download the.NET install script using

wget -O - https://raw.githubusercontent.com/dotnet/install-scripts/main/dotnet-install.sh | bash

Once the script is downloaded, you can install the.NET SDK by running

sudo apt-get install -y dotnet-sdk-9.0

Now the Aspire templates can be installed, and the sample application generated.

dotnet new install Aspire.ProjectTemplates
dotnet new aspire-starter -o AspireApp1

In order to run the.NET Aspire Starter App on a *Raspberry Pi* some additional modifications are necessary.

Assuming that the Raspberry Pi has a fixed IP address (e.g. 10.0.1.151), several changes are necessary to allow remote access.

Application Host

In the AppHost launch settings change the launch url to a static IP address:

"applicationUrl": "http://10.0.1.151:5000",

Backend Service

In the ApiService launch settings change the launch url to a static IP address:

"applicationUrl": "http://10.0.1.151:9081",

Also change the OpenApi Document server url to using the static IP address in the appsettings.json file:

"OpenApiEndpoint": "http://10.0.1.151:9081"

Web Frontend

Similar changes are required for the Web application.

In the *Web* launch settings change the launch url to a static IP address:

"applicationUrl": "http://10.0.1.151:9091",

Also change the base url for the HttpClient to using the static IP address in the appsettings.json file:

"WeatherApiEndpoint": "http://10.0.1.151:9081"

Build and Run

The Aspire AppHost can be build by using the following command from the AspireApp1.AppHost directory:

dotnet build

The build takes some time on the Raspberry Pi 4, but should be finished in a few minutes.

And finally the run command.

dotnet run --no-build

Now the Aspire orchestrator app should be available using a web browser and pointing to

http://10.0.1.151:5000

Comments

Note that the links displayed in the Aspire orchestrator app always show localhost and not the actual IP address (10.0.1.151). Currently it seems, that this behavior is hardcoded in the AspHost application (since this should be used only during local development). The actual web application (and the backend service) are available remotely using the correct IP address.

There is a workaround using the approach presented by Anthony Simmon (see here) it is fairly straightforward to fix this issue. Implement the described ReverseProxyEndpointAnnotation and ReverseProxyLifecycleHook classes.

In the AppHost Program.cs file use the new annotation WithReverseProxyEndpoint():

var apiService = builder.AddProject<Projects.AspireApp2_ApiService>("apiservice")
    .WithReverseProxyEndpoint(name: "remote", url: "http://10.0.1.151:9081");

builder.AddProject<Projects.AspireApp2_Web>("webfrontend")
    .WithReverseProxyEndpoint(name: "remote", url: "http://10.0.1.151:9091")
    .WithExternalHttpEndpoints()
    .WithReference(apiService)
    .WaitFor(apiService);

UsefulLinks

1) .NET Downloads - https://dotnet.microsoft.com/en-us/download

2) .NET Aspire - https://learn.microsoft.com/en-us/dotnet/aspire/

3) Anthony Simmons - https://anthonysimmon.com/dotnet-aspire-non-localhost-endpoints/