Thursday, August 20, 2026

Azure AI Search: Complete Guide with a Real-Time .NET Example

 

Introduction

Modern applications generate and consume enormous amounts of information—PDFs, Word documents, web pages, product catalogs, support tickets, database records, manuals, and knowledge-base articles.

Traditional database queries work well when users know the exact keywords they are looking for. But modern applications increasingly need to understand meaning and intent, not just exact words.

This is where Azure AI Search becomes extremely useful.

Azure AI Search is a managed search and retrieval service from Microsoft Azure that supports traditional full-text search, vector search, hybrid search, semantic ranking, and generative-AI/RAG scenarios. (Microsoft Learn)

A typical modern architecture looks like this:

                User
                  |
                  v
        Angular / Web / Mobile
                  |
                  v
          ASP.NET Core API
                  |
        +---------+---------+
        |                   |
        v                   v
 Azure AI Search       Azure OpenAI
        |                   |
        |<--- Context ------|
        |
        v
   Search Results
        |
        +--------> LLM
                    |
                    v
              Final Answer

This article explains Azure AI Search from the fundamentals through an end-to-end ASP.NET Core + Azure AI Search + Azure OpenAI RAG application.


1. What Is Azure AI Search?

Azure AI Search is Microsoft's cloud-based search-as-a-service platform.

It allows applications to:

  • Store searchable documents

  • Search text

  • Search using keywords

  • Search by semantic meaning

  • Perform vector similarity searches

  • Perform hybrid searches

  • Apply filters

  • Sort and facet results

  • Re-rank search results using semantic ranking

  • Retrieve grounding information for RAG applications

Microsoft documentation currently describes Azure AI Search as supporting text, vector, and multimodal content for traditional and generative search scenarios. (Microsoft Learn)

Think of it as:

Traditional Database
        |
        | Exact data retrieval
        v
     SQL Query

Azure AI Search
        |
        | Intelligent information retrieval
        v
 Keyword + Semantic + Vector + Hybrid Search

2. Why Do We Need Azure AI Search?

Suppose a company has:

100,000 PDF documents
50,000 Word documents
1 million support tickets
500,000 product descriptions

A user asks:

"How can I reset my corporate VPN password?"

A traditional SQL query might search for:

WHERE Description LIKE '%VPN%'
AND Description LIKE '%password%'

But the user could ask:

"I forgot the credentials needed to connect remotely."

The words are completely different.

A semantic/vector search engine can recognize that:

"forgot credentials"

is related to:

"reset VPN password"

This is one of the major advantages of vector and semantic search.


3. Azure AI Search vs SQL Server

Azure AI Search does not replace SQL Server.

They solve different problems.

SQL ServerAzure AI Search
Transactional dataSearch/retrieval
INSERT/UPDATE/DELETEIndexing/search
RelationshipsSearch indexes
JoinsSearch queries
ACID transactionsRelevance ranking
Structured dataText/vector content
Business transactionsInformation retrieval

A common architecture is:

SQL Server
   |
   | Product / Customer / Order data
   |
   v
ASP.NET Core
   |
   +------> SQL Server
   |
   +------> Azure AI Search

4. Important Azure AI Search Concepts

Before implementing Azure AI Search, understand these concepts.

4.1 Search Service

The Azure AI Search service is the Azure resource that provides the search engine.

For example:

my-company-search.search.windows.net

Applications communicate with this service through:

  • REST API

  • Azure SDK

  • .NET SDK

  • Python SDK

  • JavaScript/TypeScript SDK

  • Java SDK

Microsoft provides official SDKs and samples for these languages. (Microsoft Learn)


5. Search Index

A search index is similar conceptually to a database table, but it is designed specifically for search.

For example:

ProductIndex

could contain:

ProductId
ProductName
Description
Category
Price
Availability
DescriptionVector

Example:

{
  "ProductId": "P1001",
  "ProductName": "Laptop",
  "Description": "Business laptop with 16GB RAM",
  "Category": "Computer",
  "Price": 75000
}

6. Search Fields

Each index contains fields.

For example:

ProductId
ProductName
Description
Category
Price
DescriptionVector

Different fields can have different capabilities.

For example:

ProductName
    searchable

Description
    searchable

Category
    filterable

Price
    filterable
    sortable

DescriptionVector
    vector searchable

7. Documents

A document represents one searchable item inside an index.

For example:

{
    "id": "101",
    "title": "Azure AI Search",
    "content": "Azure AI Search provides intelligent search capabilities.",
    "category": "Azure"
}

Another document might represent:

PDF chunk
Product
Customer FAQ
Support ticket
Knowledge-base article
Web page

8. Full-Text Search

Traditional full-text search searches words contained in documents.

For example:

Search:
Azure Service Bus

Azure AI Search looks for matching terms in searchable fields.

This approach is particularly useful for:

  • Product codes

  • Names

  • Exact terminology

  • IDs

  • Dates

  • Specialized technical terms

Microsoft notes that keyword search can be particularly useful where exact matching matters. (Microsoft Learn)


9. Vector Search

Vector search is one of the most important capabilities for modern AI applications.

An embedding model converts text into a numerical representation called a vector.

For example:

"How do I reset my password?"

might become conceptually:

[0.021, -0.192, 0.442, ...]

The vector represents semantic information rather than simply storing individual keywords.

The user's question is also converted into a vector.

Then Azure AI Search finds documents whose vectors are mathematically similar.

Microsoft describes vector search as useful for conceptual similarity and multilingual or multimodal scenarios. (Microsoft Learn)


10. Why Vector Search Is Powerful

Consider these two sentences:

Document:
"Employees can change their credentials from the security portal."

User:
"Where can I update my password?"

There may be no exact keyword match for every word.

But semantically:

change credentials
        ≈
update password

Vector search can identify that relationship.


11. What Is an Embedding?

An embedding is a numerical representation of content.

For example:

Text
 |
 v
Embedding Model
 |
 v
Vector

Conceptually:

"Azure Functions"
        |
        v
[0.12, -0.44, 0.72, ...]

The actual vector has many dimensions.

The application stores this vector in a vector field in Azure AI Search.


12. Hybrid Search

Hybrid search combines:

Keyword Search
       +
Vector Search

in a single request.

Azure AI Search executes the text and vector searches and merges their results using Reciprocal Rank Fusion (RRF). (Microsoft Learn)

Conceptually:

                User Query
                    |
          +---------+---------+
          |                   |
          v                   v
     Keyword Search      Vector Search
          |                   |
          v                   v
      Results A           Results B
          |                   |
          +---------+---------+
                    |
                    v
                   RRF
                    |
                    v
             Combined Results

This is often a strong choice for enterprise search.


13. Semantic Ranking

Semantic ranking provides another relevance layer.

The initial results can be reranked using Microsoft's language-understanding models.

For example:

Query:
"How can I work remotely?"

Result A:
"Remote working policy..."

Result B:
"Office parking policy..."

Result C:
"VPN remote access instructions..."

Semantic ranking can identify which results are most relevant to the meaning of the query.

Microsoft describes semantic ranker as a secondary ranking stage over an initial BM25 or RRF result set. (Microsoft Learn)


14. Search Architecture

A modern Azure AI Search application can look like this:

                  Documents
                     |
       +-------------+-------------+
       |             |             |
       v             v             v
     PDF          Database       Website
       |             |             |
       +-------------+-------------+
                     |
                     v
              Data Processing
                     |
                     v
              Chunking / Cleaning
                     |
                     v
               Embeddings
                     |
                     v
             Azure AI Search
                     |
              Search Index
                     |
                     v
                 User Query
                     |
          +----------+----------+
          |                     |
          v                     v
       Keyword               Vector
       Search                Search
          |                     |
          +----------+----------+
                     |
                     v
                    RRF
                     |
                     v
              Semantic Ranker
                     |
                     v
                Top Results
                     |
                     v
                Azure OpenAI
                     |
                     v
               Final Response

15. What Is RAG?

RAG means:

Retrieval-Augmented Generation

Instead of asking an LLM to answer only from its trained knowledge, we first retrieve relevant information from our own data.

The process is:

User Question
      |
      v
Azure AI Search
      |
      v
Relevant Documents
      |
      v
Prompt + Retrieved Context
      |
      v
Azure OpenAI
      |
      v
Final Answer

Microsoft describes RAG as a pattern that grounds LLM responses in proprietary content. (Microsoft Learn)


16. Real-Time Example: Employee Knowledge Assistant

Let's build a realistic enterprise application.

Imagine a company has:

HR Policies
IT Policies
Leave Policies
Travel Policies
Insurance Documents
Employee Handbook
Security Guidelines

Employees can ask:

"How many days of annual leave can I take?"

or:

"What is the process for claiming travel expenses?"

or:

"How do I reset my VPN password?"

Instead of manually searching hundreds of documents, the application retrieves the relevant information automatically.


17. Complete Architecture

Our solution will use:

Angular
   |
   v
ASP.NET Core Web API
   |
   +--------------------+
   |                    |
   v                    v
Azure AI Search      Azure OpenAI
   |
   v
Search Index

Documents:

Azure Blob Storage
       |
       v
Document Processing
       |
       v
Chunking
       |
       v
Embeddings
       |
       v
Azure AI Search

18. Step 1 – Create Azure AI Search

In Azure Portal:

Azure Portal
     |
     v
Create a resource
     |
     v
Search service

Configure:

Subscription
Resource Group
Service Name
Region
Pricing Tier

After deployment, you will have an Azure AI Search service.


19. Step 2 – Create Azure OpenAI

Create an Azure OpenAI resource and deploy appropriate models for:

Chat / generation
+
Embeddings

The embedding model is used to convert content and queries into vectors.

The chat model generates the final response.


20. Step 3 – Store Documents

Suppose we have:

EmployeeHandbook.pdf
LeavePolicy.pdf
TravelPolicy.pdf
SecurityPolicy.pdf

A common architecture is:

Azure Blob Storage
        |
        v
Document Processing
        |
        v
Azure AI Search

Microsoft's .NET RAG tutorial similarly demonstrates a solution using Azure OpenAI, Azure AI Search, storage, and an application layer. (Microsoft Learn)


21. Step 4 – Chunk Documents

Large documents should normally be divided into smaller pieces.

For example:

LeavePolicy.pdf

        |
        v

Chunk 1
Introduction

Chunk 2
Annual Leave

Chunk 3
Sick Leave

Chunk 4
Approval Process

Chunk 5
Carry Forward Policy

Why?

Because sending an entire 100-page document to an LLM for every question is inefficient.

Instead, retrieve only the relevant chunks.


22. Example Search Document

Our index could contain:

{
  "id": "leave-001",
  "title": "Annual Leave Policy",
  "content": "Employees are entitled to annual leave according to company policy...",
  "category": "HR",
  "documentName": "LeavePolicy.pdf",
  "contentVector": [ ... ]
}

The important fields are:

id
title
content
category
documentName
contentVector

23. Create a .NET Project

Create an ASP.NET Core Web API:

dotnet new webapi -n EnterpriseSearch.Api

Install the Azure AI Search SDK:

dotnet add package Azure.Search.Documents

The official .NET SDK package is Azure.Search.Documents. (Microsoft Learn)


24. Configuration

appsettings.json:

{
  "AzureSearch": {
    "Endpoint": "https://YOUR-SEARCH-SERVICE.search.windows.net",
    "IndexName": "employee-knowledge"
  }
}

For production, avoid storing secrets directly in configuration files.

Prefer:

Managed Identity
+
Microsoft Entra ID
+
Azure Key Vault

Microsoft's current .NET RAG tutorial demonstrates managed identities for passwordless service-to-service authentication. (Microsoft Learn)


25. Create Search Service Class

Example:

using Azure;
using Azure.Search.Documents;
using Azure.Search.Documents.Models;

public class SearchService
{
    private readonly SearchClient _searchClient;

    public SearchService(
        IConfiguration configuration)
    {
        var endpoint =
            configuration["AzureSearch:Endpoint"];

        var indexName =
            configuration["AzureSearch:IndexName"];

        var credential =
            new Azure.Identity.DefaultAzureCredential();

        _searchClient =
            new SearchClient(
                new Uri(endpoint!),
                indexName,
                credential);
    }

    public async Task<List<SearchDocument>> SearchAsync(
        string query)
    {
        var options = new SearchOptions
        {
            Size = 5
        };

        options.Select.Add("id");
        options.Select.Add("title");
        options.Select.Add("content");
        options.Select.Add("documentName");

        var response =
            await _searchClient.SearchAsync<SearchDocument>(
                query,
                options);

        var results = new List<SearchDocument>();

        await foreach (var result in response.Value.GetResultsAsync())
        {
            results.Add(result.Document);
        }

        return results;
    }
}

26. Create the API Controller

[ApiController]
[Route("api/search")]
public class SearchController : ControllerBase
{
    private readonly SearchService _searchService;

    public SearchController(SearchService searchService)
    {
        _searchService = searchService;
    }

    [HttpGet]
    public async Task<IActionResult> Search(
        string query)
    {
        var results =
            await _searchService.SearchAsync(query);

        return Ok(results);
    }
}

Now the API can be called like:

GET /api/search?query=annual leave

27. Example Response

The API could return:

[
  {
    "title": "Annual Leave Policy",
    "content": "Employees are entitled to annual leave...",
    "documentName": "LeavePolicy.pdf"
  },
  {
    "title": "Employee Handbook",
    "content": "Leave requests must be submitted...",
    "documentName": "EmployeeHandbook.pdf"
  }
]

28. Adding Vector Search

For vector search, the index contains a vector field.

Conceptually:

content
contentVector

The process is:

User Query
     |
     v
Embedding Model
     |
     v
Query Vector
     |
     v
Azure AI Search
     |
     v
Similar Document Vectors

29. Hybrid Search Query

A hybrid query contains both:

search
+
vectorQueries

Conceptually:

{
  "search": "How do I apply for annual leave?",
  "vectorQueries": [
    {
      "kind": "vector",
      "vector": [ ... ],
      "fields": "contentVector",
      "k": 5
    }
  ],
  "top": 5
}

Azure AI Search executes both searches and combines their results using RRF. (Microsoft Learn)


30. Semantic Hybrid Search

For high-quality retrieval, you can combine:

Keyword
+
Vector
+
Semantic Ranking

Conceptually:

User Query
    |
    +----> Keyword Search
    |
    +----> Vector Search
              |
              v
             RRF
              |
              v
       Semantic Ranker
              |
              v
       Best Documents

This is an especially useful architecture for RAG applications. Microsoft documentation highlights hybrid search with semantic ranking as a strong relevance strategy. (Microsoft Learn)


31. Complete RAG Flow

Let's walk through an actual question.

User asks:

"How many days of annual leave can I take?"

Step 1

Angular sends:

POST /api/chat

Request:

{
  "question": "How many days of annual leave can I take?"
}

Step 2

ASP.NET Core receives the question.

Step 3

The application sends the question to the retrieval layer.

Step 4

The query is converted into a vector.

Step 5

Azure AI Search performs:

Keyword Search
+
Vector Search

Step 6

Results are merged using RRF.

Step 7

Semantic ranking can further improve ordering.

Step 8

Top relevant chunks are returned.

Example:

Annual Leave Policy
-------------------

Employees are entitled to 20 days
of annual leave per calendar year.

Step 9

The application builds a prompt:

Answer the user's question using
only the following company policy.

Context:
Employees are entitled to 20 days
of annual leave per calendar year.

Question:
How many days of annual leave can I take?

Step 10

Azure OpenAI generates:

According to the Annual Leave Policy,
employees are entitled to 20 days of
annual leave per calendar year.

32. Why RAG Is Better Than Sending Everything to the LLM

Without RAG:

User
 |
 v
LLM
 |
 v
Possible hallucination

With RAG:

User
 |
 v
Azure AI Search
 |
 v
Company Documents
 |
 v
Relevant Context
 |
 v
LLM
 |
 v
Grounded Answer

RAG doesn't automatically guarantee that every answer is correct, but it gives the model relevant source material from your organization's data.


33. Adding Citations

A production enterprise application should ideally tell users where an answer came from.

For example:

According to the Annual Leave Policy,
employees are entitled to 20 days of annual leave.

Source:
LeavePolicy.pdf
Page 4

Your index can store metadata such as:

documentName
pageNumber
chunkId
sourceUrl
department

Then your API can return:

{
  "answer": "Employees are entitled to 20 days of annual leave.",
  "sources": [
    {
      "document": "LeavePolicy.pdf",
      "page": 4
    }
  ]
}

This greatly improves trust and auditability.


34. Security in Azure AI Search

Enterprise search must consider authorization.

Suppose:

HR Documents
Finance Documents
Engineering Documents

An Engineering employee should not automatically retrieve confidential HR documents.

A production architecture should therefore consider:

User Identity
     |
     v
Authorization
     |
     v
Security Filter
     |
     v
Azure AI Search

Metadata can include:

department
userId
role
securityGroup
accessLevel

Then search filters can restrict what users are allowed to retrieve.


35. Azure AI Search and Managed Identity

For production applications, avoid this:

API Key stored in appsettings.json

Prefer:

ASP.NET Core
     |
     v
Managed Identity
     |
     v
Microsoft Entra ID
     |
     v
Azure AI Search

This eliminates the need to distribute long-lived secrets between Azure services.


36. Common Real-Time Use Cases

Azure AI Search can be used for:

Enterprise Knowledge Search

Company Documents
       |
       v
AI Search
       |
       v
Employee Assistant

E-Commerce

Products
   |
   v
AI Search
   |
   +--> Keyword
   +--> Semantic
   +--> Vector

Example:

"Find lightweight laptops for programming."

Customer Support

Support Tickets
Knowledge Base
Product Manuals
       |
       v
Azure AI Search
       |
       v
Support Copilot

Legal Document Search

Contracts
Policies
Agreements
       |
       v
Search + RAG

Healthcare Knowledge Systems

For appropriate authorized environments:

Clinical documents
Research documents
Policies
       |
       v
Search

Sensitive applications require strong access control, privacy, compliance, and human oversight.


37. Azure AI Search in Microservices Architecture

For a microservices application:

                    API Gateway
                         |
          +--------------+--------------+
          |              |              |
          v              v              v
     Product Service  Order Service  Customer Service
          |              |              |
          +--------------+--------------+
                         |
                         v
                  Search Service
                         |
                         v
                 Azure AI Search

I recommend keeping search concerns separate from transactional services.

For example:

Product Service
      |
      v
Product Database

Search Indexing Service
      |
      v
Azure AI Search

When product data changes:

Product Updated
      |
      v
Event / Message
      |
      v
Search Indexing Service
      |
      v
Azure AI Search

This avoids tightly coupling every service to the search engine.


38. Event-Driven Indexing

For large systems:

Product Service
      |
      v
Azure Service Bus
      |
      v
Search Index Worker
      |
      v
Azure AI Search

For example:

ProductUpdatedEvent

could contain:

{
  "productId": "P1001",
  "operation": "Updated"
}

The indexing worker then updates the corresponding Azure AI Search document.


39. Azure AI Search vs Elasticsearch

FeatureAzure AI SearchElasticsearch
Azure integrationExcellentGood
Microsoft ecosystemExcellentGood
Vector searchYesYes
Hybrid searchYesYes
Semantic rankingYesDifferent approach
Azure OpenAI integrationExcellentPossible
Managed Azure serviceYesDepends on offering
.NET integrationExcellentExcellent

If your application is already heavily invested in Azure, Azure AI Search is often a natural choice.


40. Azure AI Search vs Database LIKE

Bad approach for large-scale AI search:

SELECT *
FROM Documents
WHERE Content LIKE '%password%';

Better:

Azure AI Search
      |
      +-- Full Text
      +-- Vector
      +-- Hybrid
      +-- Semantic Ranking

41. Common Mistakes

Mistake 1 – Indexing entire documents as one chunk

Instead:

Document
   |
   v
Meaningful chunks

Mistake 2 – Using only vector search

Vector search is powerful, but exact keywords can be important.

For example:

INC-45872

A keyword search may be more useful than semantic similarity.

Therefore:

Keyword + Vector

is often preferable.


Mistake 3 – Sending too many search results to the LLM

Don't retrieve hundreds of chunks.

Instead:

Retrieve
   |
   v
Rank
   |
   v
Top relevant chunks
   |
   v
LLM

Mistake 4 – Ignoring security

Never assume:

"If the document is indexed,
every user can see it."

Security trimming and authorization must be designed into the solution.


Mistake 5 – Storing secrets in source code

Avoid:

const string apiKey = "xxxxxxxx";

Use:

Managed Identity
Azure Key Vault
Microsoft Entra ID

42. Performance Optimization

Important considerations include:

Chunk Size

Avoid extremely large chunks.

Use logically meaningful sections.

Top K

Retrieve a controlled number of candidates.

For example:

Top 5
Top 10
Top 20

depending on the workload.

Hybrid Search

Use hybrid retrieval when both exact matching and semantic matching matter.

Semantic Ranking

Use semantic ranking when better relevance justifies its additional cost/latency.

Filters

Apply metadata filters when possible.

For example:

department = 'IT'

or:

documentType = 'Policy'

Monitoring

Monitor:

Latency
Query volume
Failed queries
Search relevance
Token usage
LLM latency
Cost

43. Production Architecture

A more complete enterprise implementation might look like:

                    Users
                      |
                      v
                 Azure Front Door
                      |
                      v
                API Management
                      |
                      v
              ASP.NET Core API
                      |
          +-----------+-----------+
          |                       |
          v                       v
 Azure AI Search             Azure OpenAI
          |
          |
    +-----+------+
    |            |
    v            v
Vector Index   Text Index
    |
    v
Blob Storage
    |
    v
Documents

Supporting services:

Azure Key Vault
Azure Monitor
Application Insights
Azure Service Bus
Microsoft Entra ID

44. Monitoring

Use Azure monitoring tools to observe:

Search latency
Request count
Errors
Throttling
Application latency
AI model latency
Token usage

Application Insights can help trace:

HTTP Request
     |
     v
Search Query
     |
     v
Azure OpenAI
     |
     v
Response

This is especially valuable when debugging slow RAG applications.


45. How to Design a Production RAG Pipeline

A recommended pipeline is:

1. Collect documents
        |
2. Extract text
        |
3. Clean text
        |
4. Split into chunks
        |
5. Generate embeddings
        |
6. Store chunks + vectors
        |
7. Build search index
        |
8. User asks question
        |
9. Retrieve candidates
        |
10. Hybrid search
        |
11. Semantic reranking
        |
12. Security filtering
        |
13. Build context
        |
14. Call Azure OpenAI
        |
15. Return answer + sources

46. Classic RAG vs Agentic Retrieval

Azure AI Search now also provides agentic retrieval capabilities.

Classic RAG generally follows:

Question
   |
   v
Search
   |
   v
Results
   |
   v
LLM

Agentic retrieval can use an LLM to help understand and decompose more complex queries before retrieval.

Microsoft currently documents agentic retrieval as a newer retrieval approach, with some capabilities available in preview depending on the API/features used. (Microsoft Learn)

For a first production implementation, classic hybrid RAG is often easier to understand, test, and operate.


47. Recommended Technology Stack

For a Microsoft-based enterprise application:

Frontend
    Angular

Backend
    ASP.NET Core Web API

Search
    Azure AI Search

LLM
    Azure OpenAI

Embeddings
    Azure OpenAI embedding model

Storage
    Azure Blob Storage

Database
    Azure SQL

Messaging
    Azure Service Bus

Secrets
    Azure Key Vault

Identity
    Microsoft Entra ID

Monitoring
    Application Insights
    Azure Monitor

Deployment
    Azure App Service / AKS

48. Complete Request Flow

Let's summarize the complete request:

                    USER
                      |
                      v
                Angular App
                      |
                      v
              ASP.NET Core API
                      |
                      v
               User Question
                      |
                      v
             Query Processing
                      |
             +--------+--------+
             |                 |
             v                 v
        Keyword Search    Vector Search
             |                 |
             +--------+--------+
                      |
                      v
                     RRF
                      |
                      v
              Semantic Ranking
                      |
                      v
              Security Filtering
                      |
                      v
              Top Relevant Chunks
                      |
                      v
                 Prompt Builder
                      |
                      v
                Azure OpenAI
                      |
                      v
                Final Answer
                      |
                      v
             Answer + Citations
                      |
                      v
                    USER

49. Key Interview Questions

If you are preparing for a .NET/Azure interview, these are important questions.

Q1. What is Azure AI Search?

A managed Azure service for information retrieval supporting full-text, vector, hybrid, semantic, and generative-AI search scenarios.

Q2. What is vector search?

Searching for documents based on vector similarity rather than only exact keywords.

Q3. What is hybrid search?

Combining keyword/full-text and vector search in the same request and merging their rankings using RRF. (Microsoft Learn)

Q4. What is semantic ranking?

A second-stage relevance process that reranks an initial result set using language understanding models. (Microsoft Learn)

Q5. Why use Azure AI Search with Azure OpenAI?

Azure AI Search retrieves enterprise-specific information, while Azure OpenAI generates a natural-language response based on that retrieved context.

Q6. What is RAG?

Retrieval-Augmented Generation: retrieve relevant external knowledge and provide it to an LLM as context for generating an answer.

Q7. Why chunk documents?

To retrieve smaller, relevant pieces of information instead of sending entire documents to the LLM.

Q8. What is RRF?

Reciprocal Rank Fusion is used to combine rankings from multiple search result sets, including hybrid search results. (Microsoft Learn)

Q9. How do you secure Azure AI Search?

Use Microsoft Entra ID, managed identities, RBAC, and security-aware filtering/authorization appropriate to the application.

Q10. How would you integrate Azure AI Search into a .NET microservices architecture?

Use a dedicated search/indexing component, publish domain events through messaging when data changes, and update the search index asynchronously.


50. Final Takeaway

Azure AI Search is much more than a traditional search engine.

It can provide:

Traditional Search
       +
Vector Search
       +
Hybrid Search
       +
Semantic Ranking
       +
RAG Retrieval
       +
Enterprise Security

The most important architecture to remember is:

              YOUR DATA
                  |
                  v
          Azure AI Search
                  |
        +---------+---------+
        |                   |
   Keyword Search      Vector Search
        |                   |
        +---------+---------+
                  |
                 RRF
                  |
          Semantic Ranking
                  |
                  v
          Relevant Context
                  |
                  v
            Azure OpenAI
                  |
                  v
          Grounded Response

For a .NET developer, a particularly powerful enterprise stack is:

Angular
   ↓
ASP.NET Core
   ↓
Azure AI Search
   ↓
Azure OpenAI
   ↓
Azure SQL / Blob Storage
   ↓
Azure Service Bus
   ↓
Key Vault + Managed Identity
   ↓
Application Insights

This architecture can be used to build enterprise knowledge assistants, customer-support copilots, product search, document search, internal AI assistants, and RAG-based applications.

Microsoft also provides an official .NET RAG sample that combines Azure AI Search and Azure OpenAI, including document indexing and managed-identity-based authentication. (Microsoft Learn)

Official Microsoft References

In one sentence: Azure AI Search is the retrieval layer that helps your application find the right information, while Azure OpenAI is the generation layer that turns that information into a useful natural-language answer.

Wednesday, August 19, 2026

How to Migrate SQL Server Database from Local Server to Azure Cloud



Complete Step-by-Step Guide for SQL Server to Azure Migration

Moving a SQL Server database from an on-premises/local server to Microsoft Azure is a common requirement when organizations want to modernize their infrastructure, improve scalability, increase availability, and reduce the operational effort involved in maintaining physical database servers.

In this article, we will walk through the complete migration process:

Local SQL Server → Azure Storage → Azure SQL → Application Connection

We will also discuss the different Azure SQL options, backup and restore, Azure Database Migration Service (DMS), validation, application connection-string changes, and post-migration activities.


1. What Are We Migrating?

Assume we currently have the following environment:

LOCAL / ON-PREMISES SERVER
        |
        | SQL Server
        |
        +-- CustomerDB
        +-- OrderDB
        +-- ProductDB
        |
        +-- ASP.NET Core Web API
        +-- Angular Application

We want to move the database to Azure:

                         AZURE CLOUD
                              |
                    +---------+---------+
                    |                   |
               Azure SQL          Azure Storage
                    |
              CustomerDB
              OrderDB
              ProductDB
                    |
              ASP.NET Core API
                    |
                 Angular

The migration does not necessarily mean simply copying the .mdf and .ldf files to Azure.

The correct migration approach depends on the Azure target you choose.


2. Azure SQL Deployment Options

Before migrating, the first and most important decision is:

Where should the SQL Server database run in Azure?

There are three major options.

Option 1 – Azure SQL Database

Azure SQL Database is a fully managed database platform.

Microsoft manages many infrastructure tasks such as:

  • Hardware

  • Operating system

  • Database patching

  • Backups

  • High availability

  • Infrastructure maintenance

It is generally the best choice when your application can work with a database-as-a-service model.

ASP.NET Core API
       |
       v
Azure SQL Database
       |
       v
Managed by Azure

However, Azure SQL Database is not identical to a traditional SQL Server instance, so compatibility should be assessed before migration.


3. Option 2 – Azure SQL Managed Instance

Azure SQL Managed Instance provides much greater compatibility with traditional SQL Server.

It is particularly useful when your existing application depends on SQL Server instance-level capabilities or you want a more lift-and-shift-oriented migration.

For example:

ON-PREMISES

SQL Server Instance
       |
       +-- Database A
       +-- Database B
       +-- Database C
       |
       +-- Logins
       +-- SQL Agent Jobs
       +-- Cross-database functionality

can be moved toward:

AZURE

SQL Managed Instance
       |
       +-- Database A
       +-- Database B
       +-- Database C

Microsoft describes SQL Managed Instance as a suitable target when you need maximum compatibility and when your applications depend on instance-level or cross-database functionality. (Microsoft Learn)


4. Option 3 – SQL Server on Azure Virtual Machine

This is the closest approach to your existing environment.

You create an Azure VM and install/run SQL Server on it.

Azure
 |
 +-- Virtual Network
      |
      +-- SQL Server VM
             |
             +-- SQL Server
                    |
                    +-- Database

This approach is useful when you need very high compatibility with the existing SQL Server environment.

It is essentially a lift-and-shift approach.

Microsoft's current migration tooling supports SQL Server migrations to SQL Server on Azure VMs using Azure Database Migration Service. (Microsoft Learn)


5. Which Azure Option Should You Choose?

A simplified decision table is:

RequirementRecommended Target
Fully managed databaseAzure SQL Database
High SQL Server compatibilityAzure SQL Managed Instance
Almost identical SQL Server environmentSQL Server on Azure VM
Cross-database functionalityManaged Instance / Azure VM
SQL Agent and instance-level dependenciesManaged Instance / Azure VM
Modern cloud-native applicationAzure SQL Database
Lift-and-shift migrationManaged Instance / Azure VM

Do not choose the target only because it is easy to create.

First perform a compatibility and dependency assessment.


6. Migration Architecture

A typical migration architecture looks like this:

                 ON-PREMISES
              +----------------+
              | Local SQL      |
              | Server         |
              |                |
              | CustomerDB     |
              | OrderDB        |
              +-------+--------+
                      |
                      | Backup
                      v
              +---------------+
              | Azure Storage |
              | Blob          |
              +-------+-------+
                      |
                      v
              +---------------+
              | Azure Database|
              | Migration     |
              | Service       |
              +-------+-------+
                      |
                      v
              +---------------+
              | Azure SQL     |
              | Managed       |
              | Instance /    |
              | SQL Database  |
              +-------+-------+
                      |
                      v
              ASP.NET Core API
                      |
                      v
                 Angular App

For some migration scenarios, Azure DMS uses database backup files stored in Azure Storage. (Microsoft Learn)


7. Step 1 – Analyze the Existing SQL Server

Before moving anything, collect information about your existing SQL Server.

Check:

  • SQL Server version

  • SQL Server edition

  • Database size

  • Number of databases

  • Database compatibility level

  • SQL Agent jobs

  • Logins

  • Users

  • Linked servers

  • Stored procedures

  • Functions

  • Views

  • Triggers

  • SSIS packages

  • Cross-database queries

  • CLR dependencies

  • Encryption

  • External dependencies

  • Application connection strings

For example:

SELECT
    name,
    database_id,
    compatibility_level,
    state_desc
FROM sys.databases
ORDER BY name;

Check database size:

SELECT
    DB_NAME(database_id) AS DatabaseName,
    SUM(size) * 8 / 1024 AS SizeMB
FROM sys.master_files
GROUP BY database_id
ORDER BY SizeMB DESC;

This gives you an initial understanding of your environment.


8. Step 2 – Perform a Compatibility Assessment

This step is extremely important.

Do not immediately migrate a production database.

First determine whether your existing SQL Server features are supported by the Azure target.

Microsoft's current SSMS migration functionality can assess a SQL Server instance and recommend Azure SQL targets such as:

  • Azure SQL Database

  • Azure SQL Managed Instance

  • SQL Server on Azure VM

It can also identify compatibility considerations before migration. (Microsoft Learn)

A typical process is:

Discover
   |
   v
Assess
   |
   v
Identify blockers
   |
   v
Fix compatibility issues
   |
   v
Migrate

9. Step 3 – Create an Azure Account

Open the Azure Portal:

https://portal.azure.com

Sign in with your Azure account.

You need an Azure subscription.


10. Step 4 – Create a Resource Group

A Resource Group is a logical container for Azure resources.

For example:

Resource Group:
rg-production-database

You may place resources such as:

rg-production-database
 |
 +-- Azure SQL
 +-- Storage Account
 +-- Database Migration Service
 +-- Key Vault
 +-- Monitoring resources

For production environments, use a naming convention appropriate for your organization.

Example:

rg-prod-sql-eastus
rg-prod-storage-eastus

11. Step 5 – Create Azure Storage

Azure Storage can be used as an intermediate location for database backup files.

Create:

Storage Account
      |
      +-- Blob Container
             |
             +-- sqlbackups

For example:

https://mystorageaccount.blob.core.windows.net/sqlbackups/

You can place backup files here:

CustomerDB.bak
OrderDB.bak
ProductDB.bak

For migration projects using Azure DMS, Microsoft recommends using a dedicated storage account for migration-related backup files rather than sharing it with unrelated workloads. (Microsoft Learn)


12. Step 6 – Take a Full SQL Server Backup

On your local SQL Server, take a full backup.

Example:

BACKUP DATABASE CustomerDB
TO DISK = 'D:\SQLBackups\CustomerDB.bak'
WITH
    INIT,
    COMPRESSION,
    STATS = 10;

Verify that the backup completed successfully.

You can check backup history:

SELECT
    database_name,
    backup_start_date,
    backup_finish_date,
    type,
    backup_size
FROM msdb.dbo.backupset
WHERE database_name = 'CustomerDB'
ORDER BY backup_finish_date DESC;

13. Step 7 – Upload the Backup to Azure Storage

Upload:

CustomerDB.bak

to:

Azure Storage
     |
     +-- sqlbackups
           |
           +-- CustomerDB.bak

You can use Azure Storage tools or Azure-supported migration workflows.

For large databases, uploading the backup can take significant time, so estimate the transfer duration before scheduling production migration.


14. Step 8 – Create the Azure SQL Target

Now create the target.

For example, if you selected Azure SQL Managed Instance:

Azure Portal
    |
    +-- Azure SQL
          |
          +-- SQL Managed Instance

Configure:

  • Subscription

  • Resource Group

  • Region

  • Instance name

  • Compute

  • Storage

  • Networking

  • Authentication

  • Security settings

For Azure SQL Database, create:

Azure SQL Server
       |
       +-- Azure SQL Database

For SQL Server on Azure VM:

Azure VM
   |
   +-- SQL Server

15. Step 9 – Configure Networking

This is one of the most commonly overlooked parts of a database migration.

Your application must be able to reach the Azure database.

Typical architecture:

                    Internet
                       |
                       v
                Azure Front Door
                       |
                       v
                 Application
                       |
                       v
                ASP.NET Core API
                       |
                       v
                 Private Network
                       |
                       v
                Azure SQL

For production systems, consider:

  • Virtual Network

  • Private Endpoint / Private networking

  • Network Security Groups

  • Firewall rules

  • DNS configuration

  • VPN

  • ExpressRoute where required

Avoid exposing a production database unnecessarily to the public internet.


16. Step 10 – Choose Your Migration Method

There are several approaches.

Method A – BACPAC

Useful for certain Azure SQL Database migration scenarios.

Local SQL Server
       |
       | Export
       v
    .bacpac
       |
       v
Azure SQL Database

Azure SQL supports importing a BACPAC file into Azure SQL Database or SQL Managed Instance. (Microsoft Learn)


17. Method B – Backup and Restore

This is a traditional SQL Server migration approach.

Local SQL Server
       |
       | .bak
       v
Azure Storage
       |
       v
Azure SQL Managed Instance

This approach is especially useful for SQL Managed Instance.

Microsoft supports native backup/restore of SQL Server backups stored in Azure Storage for SQL Managed Instance. (Microsoft Learn)

Example:

RESTORE DATABASE CustomerDB
FROM URL =
'https://mystorageaccount.blob.core.windows.net/sqlbackups/CustomerDB.bak';

The exact credential and restore configuration depends on your target and storage authentication method.


18. Method C – Azure Database Migration Service

Azure Database Migration Service, or Azure DMS, is designed specifically for database migration scenarios.

The general workflow is:

Source SQL Server
       |
       v
Azure Database Migration Service
       |
       v
Azure SQL Target

Microsoft currently provides DMS migration paths for SQL Server to:

  • Azure SQL Database

  • Azure SQL Managed Instance

  • SQL Server on Azure VM. (Microsoft Learn)


19. Step 11 – Create Azure Database Migration Service

In the Azure Portal:

Portal
  |
  +-- Search
       |
       +-- Azure Database Migration Service

Select:

Create

Configure:

Subscription
Resource Group
Region
Service name
Networking

After deployment:

Azure Database Migration Service
              |
              +-- New Migration

20. Step 12 – Configure Source SQL Server

Provide your source SQL Server information.

Example:

Source Server:
192.168.1.50

Database:
CustomerDB

Authentication:
SQL Authentication / Windows Authentication

The exact connectivity setup depends on your migration scenario and network architecture.

If backup files are located on an on-premises network share, some DMS scenarios require a self-hosted integration runtime so the migration service can access the source environment and backup files. (Microsoft Learn)


21. Step 13 – Select the Target

Select the Azure destination.

For example:

Source:
SQL Server

Target:
Azure SQL Managed Instance

Then select:

Subscription
Resource Group
Managed Instance
Target Database

22. Step 14 – Configure Backup Storage

Tell the migration service where the backup files are located.

Example:

Storage Account
     |
     +-- sqlbackups
           |
           +-- CustomerDB.bak
           +-- CustomerDB_Log.trn

Depending on the migration mode, full and subsequent transaction-log backups may be involved.


23. Step 15 – Start the Migration

Once configuration is complete:

Validate
   |
   v
Start Migration

Azure DMS will perform the migration according to the selected migration scenario.

Monitor:

Migration Status
        |
        +-- Starting
        +-- In Progress
        +-- Validating
        +-- Completed
        +-- Failed

Microsoft's DMS documentation describes monitoring the migration from the DMS monitoring experience. (Microsoft Learn)


24. Step 16 – Monitor Migration

Do not immediately switch your application to Azure.

First verify the migration.

Check:

Database Status
Data Size
Tables
Indexes
Stored Procedures
Functions
Views
Triggers
Users
Permissions

Run:

SELECT
    name,
    state_desc
FROM sys.databases;

Then connect to the Azure target using SSMS.


25. Step 17 – Validate the Data

This is one of the most important steps.

Compare:

LOCAL DATABASE
       vs
AZURE DATABASE

Check table counts:

SELECT
    t.name AS TableName,
    SUM(p.rows) AS RowCount
FROM sys.tables t
INNER JOIN sys.partitions p
    ON t.object_id = p.object_id
WHERE p.index_id IN (0,1)
GROUP BY t.name
ORDER BY t.name;

Run the same query against the Azure database.

Compare:

Customer
Local: 1,250,000
Azure: 1,250,000

Orders
Local: 8,500,000
Azure: 8,500,000

Also validate:

  • Primary keys

  • Foreign keys

  • Indexes

  • Constraints

  • Stored procedures

  • Functions

  • Views

  • Triggers

  • Permissions


26. Step 18 – Test Application Connectivity

Suppose your existing ASP.NET Core application has:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=LOCALSERVER;Database=CustomerDB;Trusted_Connection=True;"
  }
}

After migration, the application must connect to the Azure database.

The new connection string depends on your selected Azure service and authentication method.

Conceptually:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=<AZURE-SQL-SERVER>;Database=CustomerDB;..."
  }
}

Do not hard-code production passwords into source code.

For production applications, consider Azure Key Vault and managed identity-based authentication where appropriate.


27. Step 19 – Update ASP.NET Core Configuration

For example:

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

The application code does not necessarily need to change.

Usually, the major change is the database connection configuration.

This is one of the major advantages of using Entity Framework Core with SQL Server-compatible Azure targets.


28. Step 20 – Test CRUD Operations

After changing the connection string, test:

Create

Create Customer

Read

Get Customer

Update

Update Customer

Delete

Delete Customer

Also test:

Login
Search
Reports
Transactions
Batch jobs
Background services
Stored procedures
File uploads
Notifications

29. Step 21 – Performance Testing

Do not assume that migration automatically means better performance.

Measure:

Before Migration
----------------
API Response: 250 ms
DB Query: 100 ms

After Migration
---------------
API Response: 180 ms
DB Query: 70 ms

or identify queries that became slower.

Check:

  • CPU

  • Memory

  • DTU/vCore usage depending on Azure SQL offering

  • Query duration

  • Blocking

  • Deadlocks

  • Index usage

  • Database waits

  • Connection pool usage

Use Azure monitoring capabilities and SQL performance tools to investigate performance.


30. Step 22 – Security Configuration

Production databases should be secured properly.

Consider:

Azure SQL
   |
   +-- Firewall
   +-- Private Endpoint
   +-- Microsoft Entra authentication
   +-- Managed Identity
   +-- Encryption
   +-- Auditing
   +-- Defender for SQL
   +-- Key Vault

Never publish credentials in:

GitHub
appsettings.json
Source Code
Dockerfile
Azure DevOps YAML

For production, use secure secret-management mechanisms.


31. Step 23 – Configure Backups

One major advantage of Azure SQL services is that Azure provides managed backup capabilities.

However, you should still understand:

Backup
   |
   +-- Retention
   +-- Point-in-time restore
   +-- Long-term retention
   +-- Disaster recovery

Your backup strategy should match your organization's Recovery Point Objective (RPO) and Recovery Time Objective (RTO).


32. Step 24 – Configure Monitoring

Use Azure monitoring capabilities to observe your database.

Typical monitoring architecture:

Azure SQL
   |
   +-- Azure Monitor
   |
   +-- Log Analytics
   |
   +-- Application Insights
   |
   +-- Alerts

Create alerts for important conditions such as:

High CPU
High storage usage
Connection failures
Long-running queries
Availability problems

33. Step 25 – Application Cutover

Once testing is successful, perform the final cutover.

A typical production cutover is:

1. Notify users
        |
2. Stop application writes
        |
3. Complete final synchronization
        |
4. Validate Azure database
        |
5. Update connection string
        |
6. Deploy application
        |
7. Start application
        |
8. Perform smoke testing
        |
9. Monitor

For migration methods that maintain synchronization, Microsoft recommends ensuring the target is synchronized and validated before switching application traffic. (Microsoft Learn)


34. Example Production Migration

Suppose we have:

LOCAL SERVER

Server: SQLSERVER01

Database:
SalesDB

Size:
500 GB

Application:
ASP.NET Core Web API

Frontend:
Angular

We want:

AZURE

Azure SQL Managed Instance

Database:
SalesDB

The migration architecture becomes:

                 ON-PREMISES
                     |
                     |
              SQLSERVER01
                     |
                  SalesDB
                     |
                  Backup
                     |
                     v
              Azure Storage
                     |
                     v
        Azure Database Migration
                 Service
                     |
                     v
          Azure SQL Managed
                Instance
                     |
                     v
              ASP.NET Core API
                     |
                     v
                 Angular

35. Complete Migration Flow

The complete process can be summarized as:

              LOCAL SQL SERVER
                     |
                     v
             Database Assessment
                     |
                     v
             Compatibility Check
                     |
                     v
              Choose Azure Target
                     |
          +----------+----------+
          |          |          |
          v          v          v
       SQL DB       MI       Azure VM
          |          |          |
          +----------+----------+
                     |
                     v
              Create Azure
              Infrastructure
                     |
                     v
             Create Storage
                     |
                     v
              Take Backup
                     |
                     v
          Upload / Configure
              Backup Storage
                     |
                     v
            Azure DMS / Restore
                     |
                     v
             Migration Complete
                     |
                     v
             Validate Database
                     |
                     v
             Test Application
                     |
                     v
             Performance Test
                     |
                     v
                Cutover
                     |
                     v
              Azure Production

36. Common Migration Problems

Problem 1 – Unsupported SQL Server Feature

Your local SQL Server may use a feature that isn't available on the selected Azure target.

Solution

Perform compatibility assessment before migration.


Problem 2 – Application Cannot Connect

Possible causes:

Firewall
Networking
DNS
Authentication
Connection String
Private Endpoint
Credentials

Check each layer systematically.


Problem 3 – Database Is Very Large

For a very large database, BACPAC export/import may not be the best approach.

Consider:

Azure Database Migration Service
Backup/Restore
Managed Instance Link
Log Replay Service

depending on your target and downtime requirements.

Microsoft documents multiple migration paths for SQL Managed Instance, including DMS, Managed Instance link, Log Replay Service, and native restore. (Microsoft Learn)


37. What About Minimal Downtime?

Suppose your database is:

2 TB

and your application cannot be stopped for several hours.

A simple:

Backup
   ↓
Upload
   ↓
Restore

may result in too much downtime.

Instead, consider a migration method that supports ongoing synchronization/replication, depending on your target.

The architecture becomes:

LOCAL SQL SERVER
       |
       | Initial migration
       v
AZURE DATABASE
       ^
       |
       | Continuous changes
       |
LOCAL SQL SERVER

Then:

Stop application
      |
      v
Final synchronization
      |
      v
Validate target
      |
      v
Change connection string
      |
      v
Start application

This can significantly reduce the final cutover window.

For SQL Managed Instance, Microsoft documents DMS, Managed Instance link, and Log Replay Service for migration scenarios designed to reduce downtime. (Microsoft Learn)


38. What Happens to SQL Agent Jobs?

This depends heavily on your target.

If you move to SQL Server on Azure VM, you retain a traditional SQL Server environment.

With SQL Managed Instance, many SQL Server instance-level capabilities are supported, including SQL Agent-related workloads, although you should still assess individual dependencies.

With Azure SQL Database, you should not assume that every SQL Server instance-level feature will move directly.

Therefore:

SQL Server Agent Jobs
        |
        +-- Identify
        |
        +-- Assess
        |
        +-- Recreate / redesign where required

39. What Happens to Logins and Users?

Database users and server-level logins are different concepts.

You should inventory:

Server Logins
Database Users
Roles
Permissions
Application Accounts
Service Accounts

After migration, verify that every application identity has the correct permissions.

Do not simply grant:

db_owner

to every application account.

Use the minimum permissions required.


40. What Happens to Stored Procedures?

Stored procedures generally migrate well when supported by the selected target.

After migration, execute important procedures and compare results.

For example:

EXEC dbo.GetCustomerOrders
     @CustomerId = 1001;

Compare the results between:

Local SQL Server
vs
Azure SQL

41. What Happens to SQL Server Jobs and SSIS?

Create an inventory before migration.

SQL Agent Jobs
SSIS Packages
Linked Servers
Maintenance Plans
Database Mail
Cross Database Queries
CLR
Replication

Some workloads may need redesign when moving to a fully managed Azure SQL platform.

This is one reason why assessment before migration is critical.


42. Rollback Strategy

Never perform a production database migration without a rollback plan.

Before cutover:

LOCAL DATABASE
       |
       +-- Final backup
       |
       +-- Keep source available

If something goes wrong:

Azure
  |
  X
  |
Rollback
  |
  v
Local SQL Server

Do not immediately delete the original database after migration.

Keep the source environment available until:

Application validated
Data validated
Business users approved
Performance validated
Monitoring stable
Rollback window completed

43. Production Migration Checklist

Before migration:

☐ Inventory SQL Server
☐ Check database size
☐ Check SQL Server version
☐ Assess compatibility
☐ Identify dependencies
☐ Identify SQL Agent jobs
☐ Identify logins/users
☐ Identify linked servers
☐ Choose Azure target
☐ Create Azure subscription/resource group
☐ Configure networking
☐ Create target database/server
☐ Configure Azure Storage
☐ Take backup
☐ Test restore

During migration:

☐ Start migration
☐ Monitor migration
☐ Check errors
☐ Verify database state
☐ Compare row counts
☐ Validate schema
☐ Validate indexes
☐ Validate users
☐ Validate permissions

Before cutover:

☐ Test application
☐ Test APIs
☐ Test reports
☐ Test transactions
☐ Test performance
☐ Prepare rollback
☐ Notify stakeholders

After cutover:

☐ Update connection string
☐ Deploy application
☐ Smoke test
☐ Monitor database
☐ Monitor API
☐ Monitor errors
☐ Monitor performance
☐ Obtain business approval

44. Recommended Architecture for a .NET + Angular Application

For a modern application, the architecture could look like:

                       USERS
                         |
                         v
                    Angular SPA
                         |
                         v
                Azure Front Door
                         |
                         v
                Azure API Management
                         |
                         v
                 ASP.NET Core APIs
                         |
              +----------+----------+
              |                     |
              v                     v
       Azure Service Bus       Azure SQL
              |               Managed Instance
              |                     |
              v                     v
       Background Workers       Database
              |
              v
       External Services

Additional Azure services can be introduced based on requirements:

Azure Key Vault
Azure Monitor
Application Insights
Azure Storage
Azure Container Registry
AKS / App Service
Azure Functions

45. Azure SQL Database vs Managed Instance vs Azure VM

FeatureAzure SQL DatabaseSQL Managed InstanceSQL Server Azure VM
Fully managedYesYesNo
SQL Server compatibilityModerateHighVery High
OS managementAzureAzureCustomer
SQL Server instance accessLimitedHighFull
Lift-and-shiftSometimesExcellentExcellent
Cross-database scenariosLimited compared with MIStrongStrong
SQL AgentNot traditional SQL AgentSupported scenariosFull
Infrastructure controlLowMediumHigh
Administration effortLowestMediumHighest

Always verify the current feature support for your exact SQL Server version and Azure target before production migration.


46. Recommended Approach

For a typical enterprise application currently running:

ASP.NET Core
Angular
SQL Server
Azure Services

I recommend this decision process:

                 Existing SQL Server
                         |
                         v
                Compatibility Assessment
                         |
             +-----------+-----------+
             |                       |
       Minimal changes          Cloud modernization
             |                       |
             v                       v
     SQL Managed Instance       Azure SQL Database
             |
             |
       Very high SQL
       compatibility
             |
             v
     SQL Server Azure VM

For a large existing SQL Server environment with many instance-level dependencies, Azure SQL Managed Instance is often a strong candidate.

For a modern application that can adapt to Azure SQL Database capabilities, Azure SQL Database can reduce infrastructure administration.

For applications requiring maximum control and near-traditional SQL Server behavior, SQL Server on Azure VM is the closest lift-and-shift option.


47. Final Takeaway

Migrating SQL Server to Azure is not simply:

Copy Database
      ↓
Azure

A successful migration is:

ASSESS
   ↓
PLAN
   ↓
CHOOSE TARGET
   ↓
PREPARE AZURE
   ↓
BACKUP / MIGRATE
   ↓
VALIDATE
   ↓
TEST
   ↓
CUTOVER
   ↓
MONITOR
   ↓
OPTIMIZE

The most important rule is:

Never migrate a production database directly without first performing compatibility assessment, testing the migration, validating the data, and preparing a rollback plan.

Azure provides several migration approaches, and the correct choice depends on the target platform, database size, SQL Server features, network architecture, and acceptable downtime. Microsoft currently documents Azure DMS, native backup/restore, Managed Instance link, and Log Replay Service among the available migration approaches for relevant SQL Server-to-Azure scenarios. (Microsoft Learn)

Official Microsoft References

Don't Copy

Protected by Copyscape Online Plagiarism Checker