Ultimate ASP.NET Full Course: Module 8 - Deployment, Microservices & Cloud DevOps

 

Table of Contents

1. Module 8: Deployment, Microservices & Cloud DevOps

   • 1.1 Preparing for Production

     • Configs, Environment Variables, Secrets

   • 1.2 Containerization

     • Docker Basics, Dockerfile for ASP.NET Core

   • 1.3 Hosting

     • IIS, Kestrel, Linux (Nginx), Azure App Service

   • 1.4 DevOps & CI/CD

     • Git, GitHub Actions, Azure DevOps Pipelines

     • Automated Build, Test, Deploy

   • 1.5 Microservices & Cloud

     • API Gateway (Ocelot, YARP)

     • Event-Driven Architecture (Kafka, RabbitMQ, Azure Service Bus)

     • Distributed Transactions (Saga Pattern)

     • Observability with OpenTelemetry, Prometheus, Grafana

   • 1.6 Final Capstone Project

     • Build a Cloud-Deployed Enterprise App

     • MVC Front-End, REST API Backend, EF Core Database, SignalR for Real-Time, Identity for Security, AI-Powered Features

     • Deploy via CI/CD to Azure Using Docker & Monitoring with App Insights

   • 1.7 Career Path

     • Full-Stack .NET Developer → Cloud Developer → .NET Architect

---

Introduction

Welcome to Module 8 of the Ultimate ASP.NET Full Course (2025 Edition)! This final module focuses on deploying ASP.NET Core applications to production, scaling with microservices, and implementing modern DevOps practices. You'll learn to prepare apps for production with secure configurations, containerize with Docker, host on various platforms (IIS, Kestrel, Nginx, Azure), and set up CI/CD pipelines using GitHub Actions and Azure DevOps. We'll dive into microservices architecture, including API gateways, event-driven systems, and observability tools like OpenTelemetry and Prometheus.

The capstone project ties everything together: you'll build and deploy a cloud-native e-commerce app with an MVC front-end, REST API backend, EF Core database, SignalR for real-time notifications, Identity for security, and AI-powered features like product recommendations. The app will be deployed to Azure via CI/CD, monitored with Application Insights, and containerized with Docker.

Using real-life scenarios—like an e-commerce platform managing products, orders, and user interactions—this guide is step-by-step, code-heavy, and data-oriented. It emphasizes best practices, exception handling, pros/cons, and alternatives, preparing you for production-grade development. We'll conclude with a career path from full-stack .NET developer to cloud developer and .NET architect.

By the end, you'll be ready to deploy scalable, secure, and modern .NET applications. Let's get your apps to the cloud!

---

1.1 Preparing for Production

Configs, Environment Variables, Secrets

Production-ready apps require secure, environment-specific configurations.

• Configs (appsettings.json): Store settings like connection strings.

  {
    "ConnectionStrings": {
      "DefaultConnection": "Server=prod-db;Database=ECommerceDb;Trusted_Connection=True;"
    },
    "ApiSettings": {
      "MaxItemsPerPage": 50
    }
  }

  • Load: builder.Configuration.GetSection("ApiSettings").Get<ApiSettings>();

• Environment Variables: Override settings for different environments.

  • Example: ASPNETCORE_ENVIRONMENT=Production sets environment.

  • Access: builder.Configuration["ConnectionStrings:DefaultConnection"].

• Secrets: Store sensitive data (e.g., API keys) securely.

  • Development: Use User Secrets.

    dotnet user-secrets init
    dotnet user-secrets set "ApiKey" "your-secret-key"

  • Production: Use Azure Key Vault or environment variables.

    builder.Configuration.AddAzureKeyVault(new Uri("https://myvault.vault.azure.net/"), new DefaultAzureCredential());

Real-Life Analogy: Configs are a recipe book, environment variables adjust ingredients per kitchen, secrets are locked spice cabinets.

Real-Life Example: E-commerce app uses appsettings.json for database connections, environment variables for staging/production, and Key Vault for payment API keys.

Best Practices:

• Use strongly-typed configuration (IOptions<T>).

• Avoid hardcoding sensitive data.

• Validate configs at startup.

Exception Handling:

• Handle missing config with defaults or errors.

  var connString = builder.Configuration.GetConnectionString("DefaultConnection") 
      ?? throw new InvalidOperationException("Connection string missing");

Pros:

• Flexible, secure configuration.

• Environment-specific settings.

Cons:

• Managing multiple sources complex.

• Key Vault adds setup overhead.

Alternatives:

• HashiCorp Vault: For secrets.

• YAML Configs: Less common in .NET.

Expanding: .NET 9 enhances configuration binding with source generators. Use IOptionsSnapshot for reloadable settings. Realistics: Retail apps use Key Vault for PCI compliance. Pros: Secure by default; cons: Configuration sprawl in large apps.

---

1.2 Containerization

Docker Basics, Dockerfile for ASP.NET Core

Docker containerizes apps for consistent deployment across environments.

• Docker Basics:

  • Containers: Lightweight, isolated app environments.

  • Images: Templates for containers.

  • Docker Hub: Repository for images.

• Dockerfile for ASP.NET Core:

  FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
  WORKDIR /app
  EXPOSE 80
  EXPOSE 443
  
  FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
  WORKDIR /src
  COPY ["ECommerceApp.csproj", "."]
  RUN dotnet restore "ECommerceApp.csproj"
  COPY . .
  RUN dotnet build "ECommerceApp.csproj" -c Release -o /app/build
  
  FROM build AS publish
  RUN dotnet publish "ECommerceApp.csproj" -c Release -o /app/publish /p:UseAppHost=false
  
  FROM base AS final
  WORKDIR /app
  COPY --from=publish /app/publish .
  ENTRYPOINT ["dotnet", "ECommerceApp.dll"]

• Build/Run:

  docker build -t ecommerceapp .
  docker run -d -p 8080:80 --name ecommerce ecommerceapp

Real-Life Analogy: Docker is a shipping container—standardized, portable, runs anywhere.

Real-Life Example: E-commerce app containerized for deployment to Azure Kubernetes Service (AKS).

Best Practices:

• Use multi-stage builds to reduce image size.

• Minimize layers with efficient COPY.

• Secure images with non-root users.

Exception Handling:

• Handle Docker build failures (e.g., missing dependencies).

• Monitor container logs: docker logs ecommerce.

Pros:

• Consistent environments.

• Easy scaling with orchestrators.

Cons:

• Learning curve for Docker.

• Resource overhead.

Alternatives:

• Podman: Docker alternative.

• Serverless: Azure Functions.

Details: .NET 9 optimizes Docker images with AOT compilation. Realistics: Netflix uses Docker for microservices. Pros: Portability; cons: Debugging container issues.

---

1.3 Hosting

IIS, Kestrel, Linux (Nginx), Azure App Service

Host ASP.NET Core apps on various platforms.

• IIS: Windows server hosting.

  • Setup: Install ASP.NET Core Hosting Module.

  • Config: web.config for reverse proxy to Kestrel.

• Kestrel: Built-in, cross-platform server.

  app.Run();

• Linux (Nginx): Reverse proxy to Kestrel.

  server {
      listen 80;
      location / {
          proxy_pass http://localhost:5000;
          proxy_set_header Host $host;
      }
  }

• Azure App Service: Managed PaaS.

  • Deploy: az webapp up --sku B1 --name ecommerceapp.

Real-Life Analogy: Hosting is like choosing a venue—IIS is a corporate hall, Kestrel a pop-up stage, Nginx a community center, Azure a convention center.

Real-Life Example: E-commerce app hosted on Azure App Service for scalability.

Best Practices:

• Use HTTPS in production.

• Configure Nginx for load balancing.

Exception Handling:

• Handle 502/503 errors with health checks.

Pros:

• Flexible hosting options.

• Azure simplifies scaling.

Cons:

• IIS complexity on Windows.

• Nginx setup requires Linux knowledge.

Alternatives:

• AWS Elastic Beanstalk: Similar to Azure.

• Heroku: Simpler PaaS.

Expand: .NET 9 improves Kestrel performance. Realistics: Azure for enterprise apps.

---

1.4 DevOps & CI/CD

Git, GitHub Actions, Azure DevOps Pipelines

Automate build, test, deploy workflows.

• Git: Version control.

  • Example: git commit -m "Add product endpoint".

• GitHub Actions:

  name: CI/CD Pipeline
  on:
    push:
      branches: [ main ]
  jobs:
    build:
      runs-on: ubuntu-latest
      steps:
      - uses: actions/checkout@v4
      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'
      - name: Restore
        run: dotnet restore
      - name: Build
        run: dotnet build --no-restore
      - name: Test
        run: dotnet test --no-build
      - name: Publish
        run: dotnet publish -c Release -o ./publish
      - name: Deploy to Azure
        uses: azure/webapps-deploy@v2
        with:
          app-name: ecommerceapp
          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}

• Azure DevOps: Similar pipeline setup via YAML or UI.

Automated Build, Test, Deploy:

• Build: Compile app.

• Test: Run unit tests (xUnit, NUnit).

• Deploy: Push to Azure.

Real-Life Example: E-commerce CI/CD pipeline builds/tests on commits, deploys to Azure on main branch.

Best Practices:

• Use secrets for credentials.

• Parallelize test jobs.

Exception Handling:

• Handle pipeline failures with notifications.

Pros:

• Automated workflows.

• Fast feedback loops.

Cons:

• Setup time for pipelines.

Alternatives:

• Jenkins: Open-source CI/CD.

• CircleCI: Cloud-based.

Expand: .NET 9 supports faster builds. Realistics: CI/CD for rapid e-commerce updates.

---

1.5 Microservices & Cloud

API Gateway (Ocelot, YARP)

Centralize routing for microservices.

• Ocelot: NuGet Ocelot.

  {
    "Routes": [
      {
        "DownstreamPathTemplate": "/api/products/{id}",
        "UpstreamPathTemplate": "/products/{id}",
        "DownstreamHostAndPorts": [
          { "Host": "product-service", "Port": 80 }
        ]
      }
    ]
  }

• YARP: Reverse proxy, NuGet Yarp.ReverseProxy.

Event-Driven Architecture (Kafka, RabbitMQ, Azure Service Bus)

• Azure Service Bus:

  var client = new ServiceBusClient(builder.Configuration.GetConnectionString("ServiceBus"));
  await client.CreateSender("orders").SendMessageAsync(new ServiceBusMessage("Order created"));

Distributed Transactions (Saga Pattern)

• Coordinate via events, not ACID transactions.

  public async Task HandleOrderCreated(Order order)
  {
      // Update inventory, notify user
  }

Observability with OpenTelemetry, Prometheus, Grafana

• OpenTelemetry: NuGet OpenTelemetry.Exporter.Prometheus.

  builder.Services.AddOpenTelemetry()
      .WithMetrics(builder => builder.AddPrometheusExporter());

Real-Life Example: E-commerce microservices for products, orders, notifications.

Pros/Cons: Scalable but complex.

Alternatives:

• Monolith: Simpler for small apps.

---

1.6 Final Capstone Project

Build a Cloud-Deployed Enterprise App

Create an e-commerce app with MVC, API, EF Core, SignalR, Identity, and AI features, deployed to Azure.

Step-by-Step

1. Setup: dotnet new mvc -n ECommerceApp.

2. Features:

   • MVC: Product catalog.

   • API: REST endpoints with JWT.

   • EF Core: Database for products/orders.

   • SignalR: Order notifications.

   • Identity: User management.

   • AI: Copilot-generated recommendation service.

3. Dockerfile: As above.

4. CI/CD: GitHub Actions to Azure.

5. Monitoring: Application Insights.

Code Example

Program.cs (Partial)

builder.Services.AddDbContext<ECommerceDbContext>();
builder.Services.AddIdentity<IdentityUser, IdentityRole>();
builder.Services.AddSignalR();
builder.Services.AddStackExchangeRedisCache(options => ...);
builder.Services.AddApplicationInsightsTelemetry();
app.MapHub<NotificationHub>("/notificationHub");

NotificationHub.cs

public class NotificationHub : Hub
{
    public async Task SendOrderUpdate(string userId, string message)
    {
        await Clients.User(userId).SendAsync("OrderUpdate", message);
    }
}

Dockerfile, CI/CD YAML

As above.

How to Run

• Build, containerize, deploy, monitor.

Explanation/Best Practices/etc.

• Comprehensive, production-ready app.

---

1.7 Career Path

• Full-Stack .NET Developer: Build end-to-end apps.

• Cloud Developer: Master Azure/AWS deployments.

• .NET Architect: Design scalable systems.

Steps: Certifications (AZ-204), contribute to OSS, specialize in microservices/AI.

📘Free Job Preparation Zone 🎯 Visit Free Learning Zone 📘Master ASP.NET: Complete Course Outline from Beginner to Advanced