What Azure/AWS services have you worked with for .NET applications?

Here's an overview of commonly used cloud services for .NET Core applications:

Azure Services

Compute:

1. Azure App Service
   • Managed platform for hosting web apps, APIs, and mobile backends
   • Built-in CI/CD, auto-scaling, custom domains, SSL
   • Best for: Web APIs, web applications, background jobs

// Program.cs - optimized for Azure App Service
var builder = WebApplication.CreateBuilder(args);

// Azure App Service provides HTTPS automatically
builder.Services.AddHttpsRedirection(options =>
{
    options.HttpsPort = 443;
});

// Add Application Insights
builder.Services.AddApplicationInsightsTelemetry();

var app = builder.Build();

// Configure for Azure App Service
app.UseForwardedHeaders();
app.UseHttpsRedirection();
app.MapHealthChecks("/health");

app.Run();

1. Azure Functions
   • Serverless compute for event-driven workloads
   • Pay per execution, auto-scaling
   • Best for: Background tasks, webhooks, scheduled jobs

[Function("ProcessOrder")]
public async Task Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
    [QueueOutput("orders")] ICollector orderQueue)
{
    var order = await req.ReadFromJsonAsync();
    orderQueue.Add(order);
    
    var response = req.CreateResponse(HttpStatusCode.OK);
    return response;
}

1. Azure Kubernetes Service (AKS)

   • Managed Kubernetes cluster
   • Best for: Microservices, complex containerized applications

2. Azure Container Instances (ACI)

   • Run containers without managing servers
   • Best for: Simple containerized apps, batch jobs

Data Storage:

1. Azure SQL Database
   • Managed SQL Server database
   • Automatic backups, patching, high availability

// Connection string from Azure Key Vault
builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{keyVaultName}.vault.azure.net/"),
    new DefaultAzureCredential());

builder.Services.AddDbContext(options =>
    options.UseSqlServer(
        builder.Configuration["ConnectionStrings:DefaultConnection"]));

1. Azure Cosmos DB
   • Globally distributed NoSQL database
   • Multiple APIs: SQL, MongoDB, Cassandra, Gremlin

builder.Services.AddSingleton(sp =>
{
    var connectionString = builder.Configuration["CosmosDb:ConnectionString"];
    return new CosmosClient(connectionString);
});

1. Azure Blob Storage
   • Object storage for unstructured data (files, images, videos)

builder.Services.AddSingleton(x =>
{
    var connectionString = builder.Configuration["AzureStorage:ConnectionString"];
    return new BlobServiceClient(connectionString);
});

// Usage
public class FileService
{
    private readonly BlobServiceClient _blobServiceClient;
    
    public async Task UploadFileAsync(Stream fileStream, string fileName)
    {
        var containerClient = _blobServiceClient.GetBlobContainerClient("uploads");
        await containerClient.CreateIfNotExistsAsync();
        
        var blobClient = containerClient.GetBlobClient(fileName);
        await blobClient.UploadAsync(fileStream, overwrite: true);
        
        return blobClient.Uri.ToString();
    }
}

1. Azure Table Storage / Azure Storage Queues
   • NoSQL key-value storage / Message queuing

Messaging & Integration:

1. Azure Service Bus
   • Enterprise message broker with topics, queues, subscriptions

builder.Services.AddSingleton(sp =>
{
    var connectionString = builder.Configuration["ServiceBus:ConnectionString"];
    return new ServiceBusClient(connectionString);
});

// Sending messages
public async Task SendMessageAsync(Order order)
{
    var sender = _serviceBusClient.CreateSender("orders");
    var message = new ServiceBusMessage(JsonSerializer.Serialize(order));
    await sender.SendMessageAsync(message);
}

1. Azure Event Grid

   • Event routing service for reactive programming

2. Azure Event Hubs

   • Big data streaming platform and event ingestion service

Security & Identity:

1. Azure Active Directory (Azure AD / Entra ID)
   • Identity and access management

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd"));

builder.Services.AddAuthorization();

1. Azure Key Vault
   • Secrets, keys, and certificate management

var keyVaultUri = new Uri(builder.Configuration["KeyVault:Uri"]);
builder.Configuration.AddAzureKeyVault(keyVaultUri, new DefaultAzureCredential());

Monitoring & Logging:

1. Application Insights
   • APM and monitoring solution

builder.Services.AddApplicationInsightsTelemetry(options =>
{
    options.ConnectionString = builder.Configuration["ApplicationInsights:ConnectionString"];
});

// Custom telemetry
public class OrderService
{
    private readonly TelemetryClient _telemetry;
    
    public async Task ProcessOrder(Order order)
    {
        var stopwatch = Stopwatch.StartNew();
        try
        {
            // Process order
            _telemetry.TrackEvent("OrderProcessed", 
                new Dictionary { ["OrderId"] = order.Id });
        }
        catch (Exception ex)
        {
            _telemetry.TrackException(ex);
            throw;
        }
        finally
        {
            _telemetry.TrackMetric("OrderProcessingTime", stopwatch.ElapsedMilliseconds);
        }
    }
}

1. Azure Monitor & Log Analytics
   • Infrastructure and application monitoring

DevOps:

1. Azure DevOps

   • CI/CD pipelines, repos, boards, artifacts

2. Azure Container Registry (ACR)

   • Private Docker registry

AWS Services

Compute:

1. AWS Elastic Beanstalk

   • Managed platform for .NET applications
   • Similar to Azure App Service

2. AWS Lambda

   • Serverless functions (supports .NET)

public class Function
{
    public async Task FunctionHandler(
        APIGatewayProxyRequest request, ILambdaContext context)
    {
        return new APIGatewayProxyResponse
        {
            StatusCode = 200,
            Body = JsonSerializer.Serialize(new { message = "Hello from Lambda" })
        };
    }
}

1. Amazon ECS / EKS

   • Container orchestration (ECS = proprietary, EKS = Kubernetes)

2. Amazon EC2

   • Virtual machines

Data Storage:

1. Amazon RDS (SQL Server)

   • Managed relational database

2. Amazon DynamoDB

   • NoSQL database

3. Amazon S3

   • Object storage (like Azure Blob Storage)

var s3Client = new AmazonS3Client(RegionEndpoint.USEast1);

// Upload file
var putRequest = new PutObjectRequest
{
    BucketName = "my-bucket",
    Key = "uploads/file.txt",
    ContentBody = "Hello S3"
};
await s3Client.PutObjectAsync(putRequest);

Messaging:

1. Amazon SQS

   • Message queuing service

2. Amazon SNS

   • Pub/sub messaging

3. Amazon EventBridge

   • Event bus for serverless applications

Security:

1. AWS IAM

   • Identity and access management

2. AWS Secrets Manager

   • Secrets management

3. AWS Cognito

   • User authentication and authorization

Typical .NET Core Architecture on Azure:

Internet
    ↓
Azure Front Door / Application Gateway (CDN, WAF, Load Balancer)
    ↓
Azure App Service / AKS (Multiple instances)
    ↓
    ├─→ Azure SQL Database (Relational data)
    ├─→ Azure Cosmos DB (NoSQL data)
    ├─→ Azure Cache for Redis (Caching)
    ├─→ Azure Blob Storage (File storage)
    ├─→ Azure Service Bus (Async messaging)
    └─→ Azure Key Vault (Secrets)
    
Monitoring: Application Insights + Azure Monitor
Identity: Azure AD
CI/CD: Azure DevOps / GitHub Actions

Cost Optimization Tips:

1. Use Azure App Service for simple apps (easier than AKS)
2. Use serverless (Functions, Logic Apps) for sporadic workloads
3. Enable auto-scaling to match demand
4. Use Azure Reserved Instances for predictable workloads (save 30-70%)
5. Implement caching (Redis) to reduce database load
6. Use Azure CDN for static content
7. Monitor with Azure Cost Management