Top 10 Azure Services Every .NET Developer Should Know

Introduction

Azure offers hundreds of services, but as a .NET developer, you don't need to know them all. Here are the top 10 services that cover most application scenarios. Mastering these will give you a solid foundation for building, deploying, and scaling production applications in the cloud.

1. Azure App Service

The go-to service for hosting web applications. App Service supports .NET, Node.js, Python, and more with built-in CI/CD, custom domains, SSL certificates, and deployment slots for zero-downtime deployments. For most .NET web applications, App Service is the right starting point — it handles scaling, patching, and load balancing automatically.

// Configure your ASP.NET Core app for App Service
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddApplicationInsightsTelemetry();
builder.Services.AddHealthChecks();

var app = builder.Build();
app.MapHealthChecks("/health");
app.MapGet("/", () => "Running on Azure App Service");
app.Run();

Deploy directly from your IDE, via GitHub Actions, or the Azure CLI with az webapp deploy.

2. Azure SQL Database

A fully managed relational database service. Perfect for Entity Framework Core applications with built-in high availability, automated backups, and intelligent performance tuning. The serverless tier is cost-effective for dev/test workloads since it auto-pauses when idle.

// Register with connection resiliency for cloud environments
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection"),
        sqlOptions => sqlOptions.EnableRetryOnFailure(
            maxRetryCount: 3,
            maxRetryDelay: TimeSpan.FromSeconds(10),
            errorNumbersToAdd: null)));

3. Azure Functions

Serverless compute for event-driven architectures. Great for background processing, webhooks, scheduled tasks, and any workload with spiky traffic patterns. The consumption plan means you pay nothing when idle.

[Function("ProcessOrder")]
public async Task Run(
    [QueueTrigger("orders")] OrderMessage message,
    [BlobInput("receipts/{OrderId}.json")] string? existingReceipt,
    FunctionContext context)
{
    if (existingReceipt is not null)
    {
        context.GetLogger<OrderProcessor>()
            .LogWarning("Order {Id} already processed", message.OrderId);
        return;
    }
    await _orderService.ProcessAsync(message);
}

4. Azure Key Vault

Store secrets, keys, and certificates securely. Never hardcode connection strings or API keys again. Key Vault integrates directly with App Service and Azure Functions through managed identity — your application accesses secrets without any credentials in code or configuration.

5. Azure Application Insights

Monitor application performance, track errors, and gain insights into user behavior. Essential for production applications. The auto-instrumentation for ASP.NET Core captures HTTP requests, dependency calls, exceptions, and custom metrics with a single NuGet package.

6. Azure Cosmos DB

A globally distributed NoSQL database for high-performance, low-latency applications. Cosmos DB supports multiple APIs (SQL, MongoDB, Cassandra) and guarantees single-digit millisecond reads at any scale. The partition key design is the most critical decision — get it right and the database scales effortlessly.

7. Azure Service Bus

Enterprise messaging service for decoupled architectures. Supports queues, topics, and subscriptions with features like dead-letter queues, sessions, and scheduled delivery. Service Bus is the backbone of reliable microservice communication:

// Publishing an event to a Service Bus topic
await using var client = new ServiceBusClient(connectionString);
var sender = client.CreateSender("order-events");

var message = new ServiceBusMessage(
    JsonSerializer.SerializeToUtf8Bytes(orderEvent))
{
    ContentType = "application/json",
    Subject = "OrderCreated",
    MessageId = orderEvent.OrderId.ToString()
};

await sender.SendMessageAsync(message);

8. Azure Blob Storage

Store unstructured data like images, documents, and backups at massive scale. Blob Storage offers hot, cool, and archive tiers for cost optimization. Combined with lifecycle management policies, you can automatically move aging data to cheaper tiers.

9. Azure Container Apps

Run containerized applications without managing infrastructure. Perfect for microservices architectures with built-in support for Dapr, KEDA-based scaling, and managed identities. Container Apps fills the gap between App Service (too simple) and AKS (too complex) for many workloads. It supports scale-to-zero, which means you only pay when your containers are handling traffic.

// Health check endpoint for Container Apps ingress
builder.Services.AddHealthChecks()
    .AddCheck("self", () => HealthCheckResult.Healthy());
app.MapHealthChecks("/health");

10. Azure OpenAI Service

Access GPT-4o, DALL-E, and embedding models through a managed Azure service with enterprise security, private networking, and content filtering. For .NET developers, Semantic Kernel provides a clean SDK for integrating AI capabilities into applications:

// Quick Azure OpenAI integration with Semantic Kernel
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(
        deploymentName: "gpt-4o",
        endpoint: config["AzureOpenAI:Endpoint"]!,
        apiKey: config["AzureOpenAI:ApiKey"]!)
    .Build();

var result = await kernel.InvokePromptAsync(
    "Summarize this customer feedback: {{$input}}",
    new KernelArguments { ["input"] = customerFeedback });

Getting Started: The Minimum Viable Stack

For a new .NET project, start with this combination:

• App Service or Container Apps for hosting
• Azure SQL or Cosmos DB for data
• Key Vault for secrets management
• Application Insights for monitoring

This covers hosting, data, security, and observability — the four pillars of any production application. Add Functions, Service Bus, and Blob Storage as your architecture evolves. Each service has integration with DefaultAzureCredential, so you can use managed identity for authentication across all of them — no connection strings or API keys in your configuration files.

Conclusion

Mastering these 10 services will cover 90% of your Azure needs as a .NET developer. Start with App Service and SQL Database, then expand as your projects grow. Each service has a free tier or pay-per-use pricing, so you can experiment without significant cost.

References

1. Azure App Service documentation — Getting started with web app hosting on Azure
2. Azure for .NET developers — Official hub for .NET development on Azure with SDKs and tutorials
3. Azure Architecture Center — Reference architectures and best practices for Azure solutions
4. Azure SDK for .NET on GitHub — Official Azure client libraries for .NET
5. Azure free account — Free tier details for Azure services to get started