AI and machine learning models have become a core part of modern applications, enabling recommendations, predictions, and personalization. Once you have trained your models locally, the next step is to deploy them in a scalable, reliable environment. Azure App Services is a fully managed platform that allows you to host web APIs, machine learning endpoints, and applications without managing servers.
In this article, we will explore how to deploy AI models to Azure App Services using ASP.NET Core, including best practices, environment configuration, and scaling considerations.
1. Understanding the Deployment Architecture
When deploying AI models, the architecture typically includes:
Components:
ASP.NET Core API
Serves as a REST endpoint for AI predictions
Hosts your ML models (ML.NET, ONNX, or external AI API integration)
AI Model Files
Could be trained ML.NET .zip models
ONNX models (.onnx) for pre-trained frameworks
External cloud APIs (optional)
Azure App Services
Provides managed hosting
Supports scaling, monitoring, and SSL
Can integrate with Azure Storage for model files
High-Level Flow:
User/App -> HTTP Request -> ASP.NET Core API -> AI Model -> Response
2. Preparing the ASP.NET Core Application
Step 1: Create a Web API Project
dotnet new webapi -n AIModelWebAPI
cd AIModelWebAPI
Step 2: Add Required Packages
For ML.NET:
dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.Data
For ONNX Runtime:
dotnet add package Microsoft.ML.OnnxRuntime
Step 3: Organize AI Models
Folder structure:
AIModelWebAPI/
Models/
sentiment_model.zip
recommendation_model.onnx
In production, you can store models in Azure Blob Storage and download them on startup.
Step 4: Implement AI Service
Services/AIService.cs
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
public class AIService
{
private readonly MLContext _mlContext;
private readonly ITransformer? _mlNetModel;
private readonly InferenceSession? _onnxSession;
public AIService()
{
_mlContext = new MLContext();
// Load ML.NET model
if (File.Exists("Models/sentiment_model.zip"))
{
_mlNetModel = _mlContext.Model.Load("Models/sentiment_model.zip", out _);
}
// Load ONNX model
if (File.Exists("Models/recommendation_model.onnx"))
{
_onnxSession = new InferenceSession("Models/recommendation_model.onnx");
}
}
public string PredictSentiment(string input)
{
if (_mlNetModel == null) return "Model not found";
var engine = _mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(_mlNetModel);
var result = engine.Predict(new SentimentData { Text = input });
return result.Prediction ? "Positive" : "Negative";
}
public float[] PredictRecommendation(float[] inputData)
{
if (_onnxSession == null) return Array.Empty<float>();
var inputTensor = new DenseTensor<float>(inputData, new int[] { 1, inputData.Length });
var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("input", inputTensor) };
using var results = _onnxSession.Run(inputs);
return results.First().AsEnumerable<float>().ToArray();
}
}
Models/SentimentData.cs
using Microsoft.ML.Data;
public class SentimentData
{
[LoadColumn(0)]
public string Text { get; set; } = string.Empty;
}
public class SentimentPrediction
{
[ColumnName("PredictedLabel")]
public bool Prediction { get; set; }
public float Score { get; set; }
public float Probability { get; set; }
}
Step 5: Create API Controller
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class AIController : ControllerBase
{
private readonly AIService _aiService;
public AIController(AIService aiService)
{
_aiService = aiService;
}
[HttpPost("sentiment")]
public IActionResult Sentiment([FromBody] string text)
{
var prediction = _aiService.PredictSentiment(text);
return Ok(new { prediction });
}
[HttpPost("recommendation")]
public IActionResult Recommendation([FromBody] float[] input)
{
var prediction = _aiService.PredictRecommendation(input);
return Ok(prediction);
}
}
3. Prepare for Azure Deployment
Step 1: Configure for Production
Program.cs / Startup.cs:
var builder = WebApplication.CreateBuilder(args);
// Add services
builder.Services.AddSingleton<AIService>();
builder.Services.AddControllers();
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
appsettings.Production.json:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
}
}
Step 2: Test Locally
dotnet run
Check endpoints:
4. Deploy to Azure App Services
Step 1: Create App Service
Login to Azure CLI:
az login
Create a Resource Group:
az group create --name AIModelRG --location eastus
Create App Service Plan:
az appservice plan create --name AIModelPlan --resource-group AIModelRG --sku B1 --is-linux
Create Web App:
az webapp create --resource-group AIModelRG --plan AIModelPlan --name AIMLWebAPI --runtime "DOTNET|7.0"
Step 2: Publish ASP.NET Core API
Publish locally:
dotnet publish -c Release -o ./publish
Deploy using Azure CLI:
az webapp deploy --resource-group AIModelRG --name AIMLWebAPI --src-path ./publish
Step 3: Configure Model Files
If using large AI models, upload them to Azure Blob Storage:
var blobClient = new BlobContainerClient(connectionString, containerName);
var modelBlob = blobClient.GetBlobClient("sentiment_model.zip");
await modelBlob.DownloadToAsync("Models/sentiment_model.zip");
Download models at startup to avoid bundling large files in your deployment package.
5. Best Practices for Production
Environment Variables
Scaling
Logging and Monitoring
Security
Model Versioning
Async Processing
6. Optional Enhancements
Auto-scaling AI endpoints using Azure App Service or AKS
GPU acceleration for ONNX or TensorFlow models using Azure VM or Azure ML
Real-time prediction APIs with WebSocket or SignalR
CI/CD pipeline using GitHub Actions or Azure DevOps
7. Folder Structure
AIModelWebAPI/
Controllers/
AIController.cs
Models/
SentimentData.cs
SentimentPrediction.cs
Services/
AIService.cs
Models/
sentiment_model.zip
recommendation_model.onnx
Program.cs
appsettings.json
appsettings.Production.json
8. Conclusion
Deploying AI models to Azure App Services provides a fully managed, scalable, and secure environment for production-ready AI applications. Key takeaways:
Separate AI service logic from controllers
Use ML.NET or ONNX for model integration
Store large model files in Azure Blob Storage
Monitor, scale, and secure endpoints for production
Automate deployments using Azure CLI or CI/CD pipelines
With this setup, developers can confidently serve AI predictions from the cloud, enabling features like:
Azure App Services makes it simple to deploy, manage, and scale AI-powered APIs in a production environment.