Ravindra Devrani

In this tutorial, we are going to containerize the .NET Web API application with docker. I am assuming you are familiar with docker. At least, you should have some understandings of how docker works. However, I have covered all the steps needed to create a docker container for your application, but I am not going to cover the theoretical concepts of docker.

Last updated on:

• 20-November-2025

🔨Tools needed

• Visual Studio Code (Free)
• .Net 10.0 SDK (Free)
• Docker desktop (Free)

🧑‍💻Tech used

• .Net 10.0 Web APIs (controller APIs)
• Ms SQL Server 2025 (within a container)
• Docker compose

🍵Note: I am using windows 11 operating system. However, I also have tested it in the Linux mint xia and it is working fine.

In this tutorial we learn to create REST Apis with fastapi. We are going to use:

• FastApi for creating APIs
• PostgreSQL as a database
• SQLAlchemy as an ORM tool
• Alembic as a migration tool

Tech and tools used

• Linux os (you can use window or mac also. But with windows your commands might be a little different. I suggest you to use GitBash in windows)
• I am using uv to create project, you can download it from here
• Python 3.12
• VS Code (code editor) with extension Python by microsoft
• PostgreSQL (I am using it in a docker container, you can use installed version too)

The reason I am using uv, because it is pretty fast and I can easily manage dependencies with it.

First of all, let’s see what are we going to achieve? Let’s say we have an dotnet 9 api application.

Its appsettings.json looks like:

 "Color": "Color from appsettings",
 "Person": {
   "Name": "Name from appsettings"
 }

Let’s try to retrieve these values:

app.MapGet("/", (IConfiguration config) =>
{
    string color = config.GetSection("Color").Value ?? "No color";
    string name = config.GetSection("Person:Name").Value ?? "No name";
    return Results.Ok(new
    {
        color,
        name,
        message = "Hello there..."
    });
});

If you visit this endpoint, you will see this output:

• Azure App Configuration is a fully managed service, which provides you a way to store the configurations in a centralized store. You can store configurations of multiple apps in a single place.
• It is really helpful for cloud native application (eg. Microservices), which runs on multiple virtual machines and use multiple external services.
• It allows us to store Key-value pairs, manage feature flags, and organize configurations using labels and namespaces.
• The main benefit is, it supports dynamic refreshing. Which means, you can change config values without restarting the app.
• You can also add reference of azure key vault secret here.

Let’s see these things in action.

Azure blob storage is a storage solution provided by microsoft. You can store data like images, audio, video, json files, zip files etc etc in the azure.

What are we going to learn?

• How to create a web application that stores and manipulate the images in the cloud.
• We will perform all the CRUD (create, read, update and delete) operations.

Tech used

• .NET Core 9 (MVC app)
• SQL server 2022
• Azure storage account

High level overview

• We will save image url in the database and images in the storage account(blob container)

Let’s create an storage account first

Step 1:

Azure Cosmos DB for NoSQL is a fully managed and serverless NoSQL and vector database for modern app development, including AI applications and agents. With its SLA-backed speed and availability as well as instant dynamic scalability, it is ideal for real-time NoSQL applications that require high performance and distributed computing over massive volumes of NoSQL and vector data.

Soruce: learn.microsoft.com, you can learn more about it from here

Asynchronous task is a non-blocking task. Main thread goes back to the thread pool (and free to do other tasks) when it reaches to await – and new thread is assigned when wait is complete.

It is different from the multi-threading. In multi-threding, task is divided between multiple threads. Cores of your CPU are utilized.

Analogy

Let’s say you have some chores like:

1. Boiling eggs 🫕 (or sweet potatoes🍠🍠 if you dont eat eggs 🥚🥚)
2. Clean 🧹🪣 the house

There are multiple ways to achieve this:

• Direct or traditional approach: Object creates its own dependencies.

• Inverted approach (inversion of control): Dependencies are created outside the object. This responsibility is given to someone else.

Example 1 (Direct approach):

We have a service named EmailService which is an implementation of INotificationService.

public interface INotificationService
{
    void SendNotification();
}

public class EmailService : INotificationService
{
    public void SendNotification()
    {
        // code to send notification 
    }
}

OrderService need to use the INotificationService.

Please visit this post first, where I have made this project from scratch and wrote CRUD APIs.

Source code

• Backend and specific only to this tutorial: https://github.com/rd003/ng-node-fullstack/pull/new/jwt-refresh
• Complete project with angular : https://github.com/rd003/ng-node-fullstack

JSON web token (JWT) and why it is needed

REST Apis are session less. You can not maintain the authentication session for the whole application. For that purpose, JSON web token (JWT) comes in play. How it works

In this tutorial, you’ll learn how to build a simple CRUD (Create, Read, Update, Delete) REST API using Node.js, Express.js, Sequelize, and SQL Server. I have tried to make it a less verbose. It is more like a technical documentation to create the rest apis in this tech stack. However, I have tried to explain all the essential things. This is ideal if you’re looking to integrate a SQL Server database with a Node.js backend using Sequelize as the ORM. We are using sql server in this tutorial but you can easily replace it with other sql databases.