dotnetthoughts

How to use identity to secure a Web API backend for single page apps

2023-12-19T00:00:00+00:00

This post is about how to use Identity to secure a Web API backend for SPAs such as Angular, React, and Vue apps. Unlike ASP.NET Core MVC, Web API projects doesn’t support the --auth Individual option while creating the Web API project from dotnet SDK. We have to manually add the nuget package references. So first we need to create a web api project, we can do that using the following command - ` dotnet new webapi –name Weatherforecast.Api –output Weatherforecast`. Next we need to add reference of different NuGet packages. I am using Sql Server as the backend.

dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design

The first NuGet package is for getting the identity related objects. The other two for database interactions and for creating and running migrations.

Once the NuGet packages added, we can create the DbContext class which should be inheriting from IdentityDbContext. Here is the implementation.

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace WeatherForecast.Api;

public class WeatherForecastDbContext(DbContextOptions<WeatherForecastDbContext> options) 
    : IdentityDbContext<IdentityUser>(options)
{
}

And then we can modify the Program.cs file like this. First we need to configure the DbContext and then set the Identity Api endpoints, like this.

var connectionString = builder.Configuration.GetConnectionString("WeatherForecastDbConnection");
builder.Services.AddDbContextPool<WeatherForecastDbContext>(options => options.UseSqlServer(connectionString));

builder.Services.AddAuthorization();
builder.Services.AddIdentityApiEndpoints<IdentityUser>()
    .AddEntityFrameworkStores<WeatherForecastDbContext>();

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.MapIdentityApi<IdentityUser>();

Also we need to update the appsettings.json with the Sql server connection string. Now we have completed the configuration. Next we can create migrations using the command dotnet ef migrations add InitialMigrations, then create database and apply migrations using dotnet ef database update command.

Now we are ready to run the web api. To protect the Api endpoints, we can use RequireAuthorization() extension method. To protect the /weatherforecast we can do like this.

app.MapGet("/weatherforecast", () =>
{
    var forecast =  Enumerable.Range(1, 5).Select(index =>
        new WeatherForecastItem
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast")
.WithOpenApi().RequireAuthorization();

For controller based projects, we can use the [Authorize] attribute as well. The RequireAuthorization() method can accept claims or roles if we want to control the access based on specific claims or role.

Here is the screenshot of the swagger UI.

Here is the complete Program.cs

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("WeatherForecastDbConnection");
builder.Services.AddDbContextPool<WeatherForecastDbContext>(options => options.UseSqlServer(connectionString));

builder.Services.AddAuthorization();
builder.Services.AddIdentityApiEndpoints<IdentityUser>()
    .AddEntityFrameworkStores<WeatherForecastDbContext>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.MapIdentityApi<IdentityUser>().WithTags("Identity");

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

var summaries = new[]
{
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};

app.MapGet("/weatherforecast", () =>
{
    var forecast =  Enumerable.Range(1, 5).Select(index =>
        new WeatherForecastItem
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast")
.WithOpenApi().WithTags("WeatherForecast")
.RequireAuthorization();

app.Run();

record WeatherForecastItem(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

public class WeatherForecastDbContext(DbContextOptions<WeatherForecastDbContext> options) 
    : IdentityDbContext<IdentityUser>(options)
{
}

This way we can configure ASP.NET Core Identity to protect a Backend API. This method works well with both Cookie based and Token based authentication models.

Happy Programming.

Getting started with .NET Aspire

2023-12-17T00:00:00+00:00

This post is about installing dotnet aspire. The .NET Aspire is an opinionated, cloud ready stack for building observable, production ready, distributed apps. .NET Aspire is delivered through a collection of NuGet packages that handle specific cloud-native concerns. Cloud-native apps often consist of small, interconnected pieces or microservices rather than a single, monolithic code base. Cloud-native apps generally consume a large number of services, such as databases, messaging, and caching.

For installing .NET Aspire, first we need to install .NET Aspire workload, we can do it by running the following command - dotnet workload install aspire. Since it is a preview we need Visual Studio 2022 Preview, currently it will not work with .NET Aspire Visual Studio. For installing the .NET Aspire, we can select the Visual Studio 2022 preview and select the .NET Aspire SDK (Preview) option under ASP.NET and web development workload.

We need to install Docker desktop as well - which will help us to work with Redis or any other services. We can download the latest version of Docker for Desktop here: https://www.docker.com/products/docker-desktop/.

Once we install the .NET Aspire SDK, we can run the command - dotnet new list to verify the installation is successful or not. Once we run this command we will be able to see the screen like this.

In this blog post I am using the dotnet cli to create the .NET Aspire project. To create the project we can run the command - dotnet new aspire-starter --use-redis-cache --output HelloWorldAspire.

This command will create a solution with one blazor frontend application, web api service and two other projects related to the Aspire hosting. This command will also configure Redis connection. With VS Code, we can run and debug the AppHost project. Select the Program.cs, and select the Debug option, which will launch the Aspire Dashboard application, from the screen we can launch the web frontend app. Clicking on the Weather menu will fetch the weather data from Web API.

This way we can create and debug .NET Aspire applications. We will learn more about Aspire in the upcoming blog posts.

Happy Programming.

Building Sql Server Database projects with dotnet CLI

2023-12-14T00:00:00+00:00

This post is about creating sql server database using dotnet CLI.

Install SqlPackage

First we need to install the dotnet tool SqlPackage. We can do it by the command - dotnet tool install -g microsoft.sqlpackage. This tool will helps to deploy the database changes to the database.

Create a SQL project

To create the Sql project, first we need to install the dotnet project templates. To install the Sql project templates we can execute the following command - dotnet new -i Microsoft.Build.Sql.Templates - this will install the Sql project templates from NuGet.org. Once we install the template, we can create the project using the following command - dotnet new sqlproj --name HelloWorld. Once the project is created, we can open the project in Visual Studio Code. Currently we can’t open the Sql Project in Visual Studio.

Next we can add table script to the file - I am using a TodoItems table script. We can add it directly to the project level. The recommended structure is like this - <Sql Object type>\<Schema>\<Name> - for this example - Tables\dbo\TodoItems.sql.

Here is the TodoItems.sql script.

CREATE TABLE [dbo].[TodoItems]
(
    Id INT IDENTITY(1,1) PRIMARY KEY,
    [Description] NVARCHAR(MAX),
    IsCompleted BIT
)

Once you add the file, we can run the dotnet build command to generate the dacpac file - which we can restore to Sql Server. Or we can use the sqlpackage tool to deploy the scripts to Sql Server.

Deploy SQL Project

To deploy the SQL project, we need to execute the following command - sqlpackage /Action:Publish /SourceFile:bin/Debug/HelloWorld.dacpac /TargetConnectionString:"Server=localhost;database=helloworlddb;User Id=sa;Pwd=SuperSecret;TrustServerCertificate=true;Connection Timeout=60;" - this command will deploy the changes to the local Sql Server. The SourceFile parameter specifies the dacpac file and the TargetConnectionString parameter specifies the Sql server connection string to deploy.

For Azure Sql Server, this command may not work because of Sql Server version issues. To fix this, open the project file and change the existing <DSP> value to this one - <DSP>Microsoft.Data.Tools.Schema.Sql.SqlAzureV12DatabaseSchemaProvider</DSP>

We can find for more details about sqlpackage command using the sqlpackage /? command.

Configuring Deployment to Azure using GitHub actions.

In GitHub actions, we can directly use SqlProj without running the dotnet build command. To do this, we can use azure/sql-action action. Here is the GitHub action.

name: Azure Database Deployment
on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Azure SQL Deploy
        uses: Azure/sql-action@v2.2.1
        with:
          connection-string: ${{ secrets.AZURE_SQL_CONNECTION_STRING }}
          path: './HelloSqlProject.sqlproj'
          action: 'publish'
          build-arguments: '/p:DropObjectsNotInSource=true'

Here is the screenshot of the database deployment GitHub action.

This way we can create Sql Project in SDK style - which is helpful in scenarios where we have the dedicated database development team. This way we can configure continuous deployment to Azure Sql Server using GitHub actions.

The project source and github action available here - https://github.com/anuraj/HelloSqlProject

Happy Programming.

Integrate OpenAI API in ASP.NET Core

2023-11-28T00:00:00+00:00

This post is about integrating Open AI API in ASP.NET Core. We can integrate Open AI using REST API and using Open AI SDK.

Configuring Open AI in Azure Portal

First we need to create an Azure Open AI instance and deploy a model. Open Azure portal, search for Azure Open AI. And click on Create button. In the Basics screen, we need to select or create new resource group, select Region, configure Name and select Pricing tier - currently Standard S0 only available.

In the Network tab, we can select the default one - All networks, including the internet, can access this resource.. We can associate tags if required, and finally we can look into the configuration and create the resource. Once it is created, we can go to the resource.

For integrating Open AI service, we need keys and endpoint, we can select Keys and Endpoint menu. Then we need to deploy models, we can select the Model deployments menu - currently it is part of Azure OpenAI Studio, we can click on the Manage deployments button which will open Azure AI Studio. In the Azure AI Studio select Deployments tab, click on Create new deployment button. In the dialog, we need to select the model to use - for this post I am using gpt-35-turbo, Model version, select the default, and finally set the Deployment name - this value we will be using the code.

This may take some time. Once it is completed successfully, we can start consuming the Open AI API in the ASP.NET Core web application.

Integrating Open AI with ASP.NET Core web app

As mentioned earlier, we can integrate Open AI in ASP.NET Core using REST APIs and using Open AI C# SDK. We will be looking into both these approaches. First we need to create an ASP.NET Core project, I am using an MVC project for the demo. We can create using dotnet new mvc -o OpenAIDemoWebApp command.

Using REST API

All the Open AI services are versioned using the api-version query parameter. All versions follow the YYYY-MM-DD date structure. Currently the version is 2023-09-15-preview.

In the program.cs file add the following code to configure the dependency injection of HTTP Client.

builder.Services.AddHttpClient("OpenAIClient", client =>
{
    client.BaseAddress = new Uri("https://dotnetthoughts.openai.azure.com/");
    client.DefaultRequestHeaders.Clear();
    client.DefaultRequestHeaders.Add("api-key", $"{builder.Configuration["OpenAIAPIKey"]}");
});

And in the controller action method, we can consume it like this.

public class OpenAIDemoController(ILogger<OpenAIDemoController> logger, IHttpClientFactory httpClientFactory) : Controller
{
    private readonly ILogger<OpenAIDemoController> _logger = logger;
    private readonly IHttpClientFactory _httpClientFactory = httpClientFactory;

    public async Task<IActionResult> Interact()
    {
        var openAiClient = _httpClientFactory.CreateClient("OpenAIClient");
        var response = await openAiClient.PostAsync("openai/deployments/dotnetthoughts/completions?api-version=2023-09-15-preview", 
            new StringContent(JsonSerializer.Serialize(new { prompt = "Once upon a time", max_tokens = 5 }), Encoding.UTF8, "application/json"));
        var responseContent = await response.Content.ReadAsStringAsync();

        return View();
    }
}

The URL will be in the following format openai/deployment/[YOUR_DEPLOYMENT_NAME]/completions?api-version=2023-09-15-preview.

This way we can interact with Open AI using REST. This method is useful when we don’t have a SDK available, for example, if we want to interact with Open AI API from Php or some other languages. For C# and .NET there is an SDK available, we will explore that in the next section.

Using Azure.AI.OpenAI nuget package

To use the SDK, first we need to reference the NuGet package to the project. We can do this by running the command - dotnet add package Azure.AI.OpenAI --version 1.0.0-beta.5. Please note, this package is in preview right now. Once we add this NuGet package, we will get classes and extension methods to interact with Azure Open AI service.

In the program.cs we can add the following code to inject the OpenAIClient class.

builder.Services.AddSingleton(new OpenAIClient(new Uri("https://dotnetthoughts.openai.azure.com/"),
       new AzureKeyCredential(builder.Configuration["OpenAIAPIKey"]!)));

And in the controller action, we can do something like this.

public class OpenAIDemoController(ILogger<OpenAIDemoController> logger, OpenAIClient openAIClient) : Controller
{
    private readonly ILogger<OpenAIDemoController> _logger = logger;
    private readonly OpenAIClient _openAIClient = openAIClient;

    public async Task<IActionResult> Interact()
    {
        var completionsResponse = await _openAIClient.GetCompletionsAsync(
            deploymentOrModelName: "dotnetthoughts",
            new CompletionsOptions()
            {
                Prompts = { "Once upon a time" },
                MaxTokens = 5
            }, cancellationToken);

        var completions = completionsResponse.Value;

        return View();
    }
}

We can use the Open AI Client SDK in ASP.NET Core.

This way we can make our ASP.NET Core applications intelligent using Azure Open AI.

Happy Programming.

Creating Microsoft Teams Applications with Visual Studio and .NET

2023-11-25T00:00:00+00:00

This post is about creating Microsoft Teams applications with Visual Studio and .NET. For creating Microsoft Teams applications, I am using the Teams Toolkit - which will make teams apps development simple. It is available in VS Code as well. We also require Microsoft 365 Developer account which we can create free.

Installing the Teams Toolkit

To install Teams Toolkit, open the Visual Studio Installer, and select modify option, under ASP.NET and Web Development workload, select Microsoft Teams development tools. This will install the required project templates and tools for creating and managing Microsoft Teams Apps from Visual Studio.

Creating new Teams application

Once Teams Toolkit installed, we can open Visual Studio, and click on the New > Project, from the list of platforms, we can select Microsoft Teams - which will filter the project templates and will display Microsoft Teams App project.

We can click on Next to create new project, in the next screen we can configure the name and location of the application. Then when clicking on the Create button will popup a screen where we can select different types of Teams applications we can create. In this example, I am using Notification Message - which will help us to display notification on Teams.

Here is the details of the other types of applications.

Template	Description
Tab	This project template will help us to display a user interface in Teams. We can use this template to move existing apps to Teams without full rewriting of the application.
Echo Bot	This is a simple Bot template which respond with the text we input in the chat window
Chat Notification Message	This is also kind of Bot - which will display messages in chat - which can be triggered using Http endpoints and timer trigger. When we select this template, we will be able to configure the trigger.
Chat command	This is similar to echo bot - but useful in simple command execution scenarios.

There are few new templates also available. I am not discussing about them in this blog post. As mentioned earlier we will be looking into the Chat Notification Message template.

The first Trigger type is HTTP Trigger (ASP.NET Core Web API) which will trigger notification message when we sending a POST request to API endpoint. The other three triggers using Azure Functions, HTTP Trigger, Timer Trigger and HTTP + Timer Trigger - with two Azure functions. I am using ASP.NET Core Web API trigger.

Project structure

The project is an ASP.NET Core Web API application with extra configuration values and extra services.

In the project, the teamsapp.local.yml and teamsapp.yml files help us to debug and deploy Bot Application - when we build the application, Teams toolkit will provision various resources using the yml files based on the environment. Output of the yml files generated under the env folder. Resources folder contains the JSON file for Adaptive card. The TeamsBot.cs file is the implementation of TeamsActivityHandler. The infra folder contains various bicep files to deploy the Bot application.

Debugging the application

To debug the project, first we need to configure Dev Tunnel - which will help us to expose the localhost URL to Teams. We can click on the Microsoft Teams (browser), and select Dev Tunnels, and then select Create a Tunnel which will bring a dialog like this.

We need to select the Visual Studio / Github subscription, set a name, set the Tunnel type as Temporary, select the access as Public. Once the dev tunnel is created, we can right click on the project, select Teams Toolkit menu and click on the Prepare Teams app dependencies menu.

This will prompt to login to our M365 Developer account - this is required because custom teams applications requires side loading permission - which may not be available for us with the live teams tenants. We can select it and then Visual Studio will provision various resources using the yml files. And once it is completed, Visual Studio will show a message.

Next we can run the application using F5 or Debug menu.

Testing the application

Once we start the application, it will open a browser window, and load teams. Please note currently it will not work with Desktop clients. And if you try to use latest version of Teams in browser that may not work. Currently it will only work with classic version. Then it will prompt an installation screen like this.

We can click on the Add button and install the app. Next we can open powershell or using Postman we can send empty post request to the URL which will display a message like this. We can use the following command to send a POST request using Powershell - Invoke-WebRequest -Uri "http://localhost:5130/api/notification" -Method Post

The notification contains hard coded values, which will can modify in the NotificationController class, and implement like this.

[HttpPost]
public async Task<ActionResult> PostAsync([FromBody]NotificationDefaultModel notification, CancellationToken cancellationToken = default)
{
    // Read adaptive card template
    var cardTemplate = await System.IO.File.ReadAllTextAsync(_adaptiveCardFilePath, cancellationToken);

    var pageSize = 100;
    string continuationToken = null;
    do
    {
        var pagedInstallations = await _conversation.Notification.GetPagedInstallationsAsync(pageSize, continuationToken, cancellationToken);
        continuationToken = pagedInstallations.ContinuationToken;
        var installations = pagedInstallations.Data;
        foreach (var installation in installations)
        {
            // Build and send adaptive card
            var cardContent = new AdaptiveCardTemplate(cardTemplate).Expand
            (
                notification
            );
            await installation.SendAdaptiveCard(JsonConvert.DeserializeObject(cardContent), cancellationToken);
        }

    } while (!string.IsNullOrEmpty(continuationToken));

    return Ok();
}

Next using an HTTP file, we can send a Post request with the notification body, like this.

POST http://localhost:5130/api/notification
Content-Type: application/json

{
  "Title": "Hello World",
  "AppName": "HelloWorld Bot",
  "Description": "This is a notification message sent from HTTP files to display the notification in Microsoft Teams.",
  "NotificationUrl": "https://aka.ms/teamsfx-notification-new"
}

Which will display a notification like this.

We can also modify the card design using Adaptive cards and customize the look of the notification.

Resources

Happy Programming.

Create a web API with ASP.NET Core and MongoDB

2023-10-24T00:00:00+00:00

This post is about configuring Mongo DB and creating ASP.NET Core Web API to work with Mongo DB using MongoDB.EntityFrameworkCore nuget package. Recently MongoDB team announced a EF Core provider for MongoDB. Earlier this year I blogged about MongoDB and ASP.NET Core using MongoFramework nuget package. In this blog post we are using MongoDB.EntityFrameworkCore nuget package which is from MongoDB.

Setting up MongoDB

For configuring MongoDB we can use Docker. First we can run the command - docker run --name mongo-db --publish 27017:27017 -v mongovolume:/data/db -d mongo:latest - the --name parameter helps us to identify the name of the container. The --publish parameter helps us to expose the 27017 port, and --volume parameter helps us to persist the data - it is optional. Once the Mongo DB running, we can use the connection string like this in ASP.NET Core - mongodb://localhost:27017

Setting up the Web API

First we need to create a Web API, we can do this by running the command dotnet new webapi --name BooksApi --output BooksApi --use-minimal-apis. Next we need to add reference of the MongoDB.EntityFrameworkCore nuget package - we can do this with the command - dotnet add .\BooksApi\ package MongoDB.EntityFrameworkCore --prerelease - since it is preview we need the --prerelease parameter. Now we have completed the Web API setup. Next open the project using VS Code. We can create a BookEntity class - which represents the MongoDB collection, Book class which is a view model class. And we need to create and configure DbContext class.

using MongoDB.Bson;

namespace BooksApi.Models;

public class BookEntity
{
    public ObjectId Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;
    public string? Description { get; set; }
    public string? Genre { get; set; }
    public DateTime PublishDate { get; set; }
    public string? Publisher { get; set; }
    public decimal Price { get; set; }
    public string? Isbn { get; set; }
}

In the BookEntity class for the Id property ObjectId is the type. Here is code for Book view model class.

namespace BooksApi.ViewModels;

public class Book
{
    public string Title { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;
    public string? Description { get; set; }
    public string? Genre { get; set; }
    public DateTime PublishDate { get; set; }
    public string? Publisher { get; set; }
    public decimal Price { get; set; }
    public string? Isbn { get; set; }
}

The Book view model class is similar to the BookEntity class except the Id is not part of the Book class. Next we can create the DbContext class.

using BooksApi.Models;
using Microsoft.EntityFrameworkCore;

namespace BooksApi.Data;

public class BooksApiDbContext(DbContextOptions<BooksApiDbContext> options) 
    : DbContext(options)
{
    public DbSet<BookEntity> Books { get; set; }
}

I am using the primary constructor feature of .NET 8.0 / C# 12 for the database context. And finally we can configure DbContext as part of dependency injection.

var connectionString = builder.Configuration.GetConnectionString("MongoDbConnection")
    ?? throw new InvalidOperationException("Connection string is null");

var databaseName = builder.Configuration.GetConnectionString("MongoDbDatabaseName") ?? "BooksStoreDb";
builder.Services.AddDbContext<BooksApiDbContext>(options => options.UseMongoDB(connectionString, databaseName));

I am using the simple overload - there are other overloads are available as well - which accepts the MongoClient instance and all.

Now we are ready to implement the CRUD methods.

Web API implementation

Like any other dependency we will be able to get the instance of DbContext in the minimal API methods like this.

app.MapGet("/books", async Task<Results<Ok<IEnumerable<Book>>, NotFound>> (BooksApiDbContext booksApiDbContext,
    CancellationToken cancellationToken = default) =>
{
    var books = (await booksApiDbContext.Books.ToListAsync(cancellationToken))
        .Select(book => new Book
        {
            Title = book.Title,
            Author = book.Author,
            Description = book.Description,
            Genre = book.Genre,
            PublishDate = book.PublishDate,
            Publisher = book.Publisher,
            Price = book.Price,
            Isbn = book.Isbn
        });

    return TypedResults.Ok(books!);
})
.WithName("GetBooks")
.WithOpenApi();

Like this we will be able to implement all the CRUD methods. Full code implementation is available on GitHub. This nuget package is still in preview. If you encounter any issues / bugs report them. Here is the Youtube video which explains about the NuGet package and how to use it.

Happy Programming.

Working with dotnet8 projects in Visual Studio 2022

2023-10-09T00:00:00+00:00

Recently Microsoft released .NET 8.0 RC. And when we try to load a .NET 8 Web API project in Visual Studio - we will get a message like this. - The current Visual Studio version does not support targeting .NET 8.0. Either target .NET 7.0 or lower, or use Visual Studio version 17.8 or higher.

We can fix this issue by changing the Visual Studio configuration like this. Click on the Tools > Select options. And under Environment, select Preview Features. And in the right side select the Use previews of the .NET SDK (requires restart).

Once it is selected, we need to restart the Visual Studio. Once it opened again, we will be able to load .NET 8.0 RC projects and we will also able to create new .NET 8.0 projects using VS 2022.

Here is an example Web API AOT project template which is part of .NET 8.0

And we can also select the .NET 8.0 as Framework for new ASP.NET Core Web API project.

This way we can configure .NET 8.0 SDK in Visual Studio 2022.

Happy Programming.

How to use native AOT to improve performance of ASP.NET Core apps

2023-09-30T00:00:00+00:00

This post is about explains what native AOT is and why it is beneficial for ASP.NET Core apps. Native AOT is a deployment model that uses an ahead-of-time compiler to compile IL to native code at the time of publish. Native AOT apps have faster startup time, smaller memory footprints, and can run on machines that don’t have the .NET runtime installed. Please note all the ASP.NET Core features are not currently compatible with native AOT. For instance, ASP.NET Core application types like minimal APIs, gRPC, and worker services are compatible with native AOT, while features such as MVC, Blazor Server, and SignalR are not supported in AOT compilation.

In this blog post I am using .NET 8.0 RC version. To create the Minimal API project with AOT, we can run the following command - dotnet new webapiaot -o HelloWorldApi - this will create a Web API project with AOT enabled. If we look into the project file, we will be able to see a new element - PublishAot it should be set to true to enable AOT, like this.

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <InvariantGlobalization>true</InvariantGlobalization>
    <PublishAot>true</PublishAot>
  </PropertyGroup>

</Project>

And in the Minimal API code, we will be able to see few more changes like the following.

builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
});

By inserting AppJsonSerializerContext.Default into the TypeInfoResolverChain, we are telling System.Text.Json to use the source-generated code for serializing and deserializing Todo[] instances, instead of relying on runtime reflection or dynamic code generation. This way, we can use System.Text.Json in .NET AOT without losing any functionality.

[JsonSerializable(typeof(Todo[]))]
internal partial class AppJsonSerializerContext : JsonSerializerContext
{

}

To use the source generator, we need to implement a JsonSerializerContext class, which is an abstract class that provides information about the types that can be serialized or deserialized by System.Text.Json. You can annotate this class with attributes to specify the types and options for source generation. The source generator will then generate a partial class that implements the abstract methods of JsonSerializerContext.

The .NET AOT uses WebApplication.CreateSlimBuilder - The advantage of using WebApplication.CreateSlimBuilder(args) is that it creates a WebApplicationBuilder instance with minimal configuration and dependencies, which can improve the performance and startup time of your web application. WebApplication.CreateSlimBuilder(args) is a new method in ASP.NET Core 8 that simplifies the creation of web applications using Minimal APIs.

Here is complete Web API code generated by the template.

using System.Text.Json.Serialization;

var builder = WebApplication.CreateSlimBuilder(args);

builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
});

var app = builder.Build();

var sampleTodos = new Todo[] {
    new(1, "Walk the dog"),
    new(2, "Do the dishes", DateOnly.FromDateTime(DateTime.Now)),
    new(3, "Do the laundry", DateOnly.FromDateTime(DateTime.Now.AddDays(1))),
    new(4, "Clean the bathroom"),
    new(5, "Clean the car", DateOnly.FromDateTime(DateTime.Now.AddDays(2)))
};

var todosApi = app.MapGroup("/todos");
todosApi.MapGet("/", () => sampleTodos);
todosApi.MapGet("/{id}", (int id) =>
    sampleTodos.FirstOrDefault(a => a.Id == id) is { } todo
        ? Results.Ok(todo)
        : Results.NotFound());

app.Run();

public record Todo(int Id, string? Title, DateOnly? DueBy = null, bool IsComplete = false);

[JsonSerializable(typeof(Todo[]))]
internal partial class AppJsonSerializerContext : JsonSerializerContext
{

}

We can create the native AOT project using the Create a new project wizard, like this.

For more information about the native AOT implementation on ASP.NET Core - Native AOT deployment

Happy Programming.

Using Docker environment variables at JavaScript runtime

2023-09-04T00:00:00+00:00

When creating a container for a single-page application with JavaScript frameworks like Angular, React, or Vue.js, we may have to inject certain configuration variables based the deployment environment. A common scenario is using API endpoint URL for the Javascript application which can vary depend on the environment. In Angular, we can use environment file for this purpose. But again the problem is we have to hard code the API URL in the environment file. In this post we will explore how we can do configure container environment variable in vanilla Javascript. This technique can be used in any Javascript framework or technology.

For hosting and running we are using Nginx Alpine. Here is the Dockerfile

FROM nginx:mainline-alpine3.18-slim

COPY docker-entrypoint.sh /usr/local/bin/

RUN chmod +x /usr/local/bin/docker-entrypoint.sh

COPY index.html /usr/share/nginx/html/index.html

ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]

We are not using nginx directly for serving the index.html page, instead we are using a shell script - docker-entrypoint.sh. Here is the implementation of docker-entrypoint.sh.

#!/bin/sh
cat <<EOF > /usr/share/nginx/html/scripts/env.js
window.API_ENDPOINT="$API_ENDPOINT";
EOF

nginx -g "daemon off;"

In the shell script, we are adding setting a Javascript variable - window.API_ENDPOINT from the $API_ENDPOINT environment variable using the cat command. Then we are starting the nginx web server with daemon mode off. And in the Dockerfile we are using this shell script as entry point - so that the env.js file will be populated and we will be running the nginx web server.

Inside scripts folder we need to create an empty Javascript file with name env.js.

Here is the index.html file.

<!doctype html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Blog</title>
    <script src="scripts/env.js"></script>
</head>

<body>
    <h1>Hello, world!</h1>
    <h2>Api Endpoint : <span id="apiendpoint"></span> </h2>
    <script src="scripts/index.js"></script>
</body>

</html>

Please note we are including the env.js file - which will set the API endpoint variable.

And here is the index.js file

document.getElementById("apiendpoint").innerHTML = "API Endpoint: " + window.API_ENDPOINT;

And when can build the image using the following command - docker build -t anuraj/staticweb:v1 . - this command will build the image and we can run the container using following command - docker run -p 8080:80 -e API_ENDPOINT="https://api.example.com" anuraj/staticweb:v1 - Please note we are passing the API_ENDPOINT as an environment variable. We can browse the application in http://localhost:8080. Here is the screenshot of the application running.

This way we can consume environment variables in Javascript - which can be used to provide server side configuration to frontend applications. Full source code available here - Docker samples

Happy Programming.

Continuous database deployments to Azure Sql Server with Bitbucket

2023-08-12T00:00:00+00:00

This post is about configuring continuous database deployments to Azure Sql Server with Bitbucket. We are deploying it using EF Core migrations. We can can modify the existing bit bitbucket-pipelines.yml file and add the following code.

- step:
    name: Database Deployment
    caches:
      - dotnetcore
    script:
        - dotnet new tool-manifest
        - dotnet tool install dotnet-ef
        - dotnet tool restore
        - dotnet ef database update --connection "$CONNECTION_STRING" --project ./src/HelloWorld.Web.csproj

We need to create a CONNECTION_STRING variable in the Bitbucket repository variables, with the Azure Sql Server connection string. Here is the screenshot of the build pipelines.

And here is the complete YAML file.

image: mcr.microsoft.com/devcontainers/dotnet:6.0

pipelines:
  default:
  - step:
      name: Build and Test
      caches:
        - dotnetcore
      script:
        - REPORTS_PATH=./test-reports/build_${BITBUCKET_BUILD_NUMBER}
        - apt-get update
        - apt-get -y install zip
        - dotnet restore
        - dotnet publish --no-restore --configuration Release --output ./publish
        - cd ./publish/
        - zip -r ../web.zip *
      artifacts:
        - 'web.zip'
  - step:
      name: Lint the code
      caches:
        - dotnetcore
      script:
        - export SOLUTION_NAME=helloworld
        - export REPORTS_PATH=linter-reports
        - dotnet new tool-manifest
        - dotnet tool install JetBrains.ReSharper.GlobalTools
        - dotnet tool restore
        - dotnet jb inspectcode ${SOLUTION_NAME}.sln --output="${REPORTS_PATH}/jb-${BITBUCKET_BUILD_NUMBER}.xml" --build
      artifacts:
        - linter-reports/**
  - step:
      name: Database Deployment
      caches:
        - dotnetcore
      script:
          - dotnet new tool-manifest
          - dotnet tool install dotnet-ef
          - dotnet tool restore
          - dotnet ef database update --connection "$CONNECTION_STRING" --project ./src/HelloWorld.Web.csproj
  - step:
      name: Azure App Service Deployment
      script:
        - pipe: microsoft/azure-web-apps-deploy:1.0.4
          variables:
            AZURE_APP_ID: $AZURE_APP_ID
            AZURE_PASSWORD: $AZURE_PASSWORD
            AZURE_TENANT_ID: $AZURE_TENANT_ID
            AZURE_RESOURCE_GROUP: 'helloworld'
            AZURE_APP_NAME: 'helloworld-dotnetthoughts'
            ZIP_FILE: 'web.zip'

If we run the pipeline, it may fail because to run query in Azure SQL, we need to enable or whitelist the IP Addresses. We can either manually add Bitbucket IP addresses or we can run the following powershell code.

$resourceGroupName="RESOURCE-GROUP-NAME"
$serverName="SQL-SERVER-NAME"

$ipAddresses=(
    "34.199.54.113", "34.232.25.90", "34.232.119.183", "34.236.25.177", "35.171.175.212",
    "52.54.90.98","52.202.195.162","52.203.14.55","52.204.96.37","34.218.156.209",
    "34.218.168.212","52.41.219.63","35.155.178.254","35.160.177.10","34.216.18.129",
    "3.216.235.48","34.231.96.243","44.199.3.254","174.129.205.191","44.199.127.226",
    "44.199.45.64","3.221.151.112","52.205.184.192","52.72.137.240"
)

foreach ($ipAddress in $ipAddresses)
{
    az sql server firewall-rule create `
        --resource-group $resourceGroupName `
        --server $serverName `
        --name "AllowIP_$ipAddress" `
        --start-ip-address $ipAddress `
        --end-ip-address $ipAddress
}

Or we can update the pipeline and include Azure CLI pipeline steps to add and remove the build pipeline server IP address, something like this.

- step:
    name: Add IP Address to Azure SQL Server
    image: microsoft/azure-cli:latest
    script:
        - IP_ADDRESS=$(curl -sS "http://checkip.amazonaws.com/")
        - pipe: microsoft/azure-cli-run:1.0.0
          variables:
            AZURE_APP_ID: $AZURE_APP_ID
            AZURE_PASSWORD: $AZURE_PASSWORD
            AZURE_TENANT_ID: $AZURE_TENANT_ID
            CLI_COMMAND: 'az sql server firewall-rule create --resource-group RESOURCE-GROUP-NAME --server SQL-SERVER-NAME --name BitbucketIp --start-ip-address $IP_ADDRESS --end-ip-address $IP_ADDRESS'

We can add this step before Database deployment step and we can add code remove the IP Address using the following code - which we can add after the Database deployment step.

- step:
      name: Remove IP Address from Azure SQL Server
      image: microsoft/azure-cli:latest
      script:
          - pipe: microsoft/azure-cli-run:1.0.0
            variables:
              AZURE_APP_ID: $AZURE_APP_ID
              AZURE_PASSWORD: $AZURE_PASSWORD
              AZURE_TENANT_ID: $AZURE_TENANT_ID
              CLI_COMMAND: 'az sql server firewall-rule delete --resource-group RESOURCE-GROUP-NAME --server SQL-SERVER-NAME --name BitbucketIp'

Here is the final build pipeline.

This way we can configure continuous database deployment from Bitbucket to Azure Sql Server with EF Core. For the demo purposes I created everything in build pipelines. We can refactor the pipeline and configure deployment section instead of everything in build.

Happy Programming.