How to Deploy an ASP.NET Core Application to Microsoft Azure App Service

 

From Localhost to the Cloud: Deploying Your ASP.NET Core App to Azure App Service

So, you've built an amazing ASP.NET Core application. It works flawlessly on your machine. But now comes the real challenge: how do you share it with the world? Manually uploading files to a server is a relic of the past. Welcome to the modern era of cloud deployment with Microsoft Azure App Service!

This guide is your one-stop shop. Whether you're a solo developer launching your first project or a seasoned pro setting up an enterprise-grade CI/CD pipeline, we've got you covered. We'll walk through everything from a simple right-click deploy to advanced scenarios with Docker containers and infrastructure-as-code.

Why Azure App Service? Pros, Cons, and Alternatives

Before we dive in, let's understand why we're choosing Azure App Service.

Pros:

• Ease of Use: Incredibly simple to get started. You can deploy in minutes.

• Fully Managed: Azure handles infrastructure maintenance, patching, and scaling for you.

• High Integration: Seamlessly integrates with other Azure services ( databases, storage, authentication).

• Multiple Deployment Options: Supports code deployment via Git, ZIP deploy, FTP, and containers.

• Powerful CI/CD: Native integration with GitHub Actions and Azure DevOps.

• Autoscaling: Can automatically scale out based on traffic to handle load.

Cons:

• Cost: While there's a free tier, production-grade plans can become expensive, especially with auto-scaling.

• Less Control: Compared to a VM (Azure Virtual Machine) or Kubernetes (AKS), you have less control over the underlying OS and software.

• Platform Limitations: Your app must conform to the App Service sandbox. Certain tasks (e.g., installing specific Windows services) are not possible.

Key Alternatives:

• Azure Virtual Machines (VMs): Full control over the OS. Better for legacy apps or specific software requirements. But you are responsible for patching and maintenance.

• Azure Kubernetes Service (AKS): The king of container orchestration. Ultimate flexibility and scalability for complex, microservices-based applications. But has a much steeper learning curve.

• Other Clouds: AWS Elastic Beanstalk or Google Cloud Run offer similar platform-as-a-service (PaaS) functionality.

For most .NET web applications, App Service is the perfect balance of power, simplicity, and cost-effectiveness.

---

Prerequisites: What You'll Need

1. An Azure Account. Create a free one here (comes with $200 credit).

2. .NET 8 SDK (or the latest LTS version) installed on your machine.

3. Visual Studio 2022 (Community edition is free) with the "ASP.NET and web development" workload.

4. A sample project. We'll create one!

---

Scenario 1: The "Right-Click" Deploy (Basic)

Perfect for your first deployment or quick prototypes.

Step 1: Create a Sample App

Open your command line or terminal and run:

bash

dotnet new mvc -n MyFirstAzureWebApp
cd MyFirstAzureWebApp
dotnet run

Navigate to https://localhost:7000 to see your app running locally.

Step 2: Publish from Visual Studio

1. Open the project in Visual Studio.

2. Right-click on the project in Solution Explorer and select Publish.

3. In the Publish dialog, choose target Azure and click Next.

4. Select Azure App Service (Windows) and click Next.

5. Sign in to your Azure account if prompted.

6. You'll now see a screen to create a new App Service instance.

   • Name: myfirstazurewebapp-12345 (must be globally unique).

   • Subscription: Choose your subscription.

   • Resource Group: Create new (e.g., MyFirstWebApp-RG).

   • Hosting Plan: Create new. Choose a Windows plan in a region close to your users. The Free F1 tier is great for testing.

   • Click Create.

Visual Studio will now provision all the necessary resources in Azure and then publish your application directly to it. Once done, it will open your new live website in the browser!

How it works: Visual Studio packages your app into a ZIP file, pushes it to Azure, and the App Service platform automatically unpacks it and hosts it on IIS (for Windows).

---

Scenario 2: Git-based Deployment with GitHub Actions (Intermediate - CI/CD)

This is the professional standard. Code is automatically built, tested, and deployed whenever you push to a specific branch in GitHub.

Step 1: Push Code to GitHub

1. Create a new repository on GitHub (e.g., MyAspNetCoreApp).

2. Push your local code to this repository.

   bash

   git init
   git add .
   git commit -m "First commit"
   git branch -M main
   git remote add origin https://github.com/your-username/MyAspNetCoreApp.git
   git push -u origin main

Step 2: Create the App Service in Azure Portal

1. Go to the Azure Portal.

2. Click "Create a resource" > "Web App".

3. Fill in the details as before (Name, Resource Group, Runtime stack = .NET 8 (LTS), OS = Windows).

4. Under the "Deployment" tab, ensure "GitHub" is selected for continuous deployment. You'll be asked to authorize Azure to access your GitHub account.

5. Skip configuring a workflow here. We'll do it manually for more control.

6. Click "Review + create", then "Create".

Step 3: Configure GitHub Actions

1. In your GitHub repository, go to Settings > Secrets and variables > Actions.

2. Click New repository secret.

3. Create a secret named AZURE_WEBAPP_PUBLISH_PROFILE.

4. To get its value, go to your newly created App Service in the Azure Portal.

   • Go to Deployment Center > Get publish profile. Download the file.

   • Open the file in a text editor and copy the entire content.

   • Paste this content as the value for the AZURE_WEBAPP_PUBLISH_PROFILE secret in GitHub.

Step 4: Create the GitHub Workflow File

In your local repository, create the following file: .github/workflows/main.yml

yaml

name: Build and deploy ASP.NET Core app to Azure Web App

on:
  push:
    branches: [ "main" ] # Trigger on push to main branch
  workflow_dispatch: # Allow manual triggers

env:
  AZURE_WEBAPP_NAME: 'myfirstazurewebapp-12345' # Set your app name here

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Setup .NET Core
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'

    - name: Build with dotnet
      run: |
        dotnet restore
        dotnet build --configuration Release --no-restore
        dotnet publish --configuration Release --no-build --output "${{ github.workspace }}/publish"

    - name: Deploy to Azure Web App
      uses: azure/webapps-deploy@v2
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{ github.workspace }}/publish

Now, commit and push this file to your main branch.

bash

git add .github/workflows/main.yml
git commit -m "Add GitHub Actions workflow"
git push origin main

Magic Time! Go to the Actions tab in your GitHub repository. You will see a workflow running. Once it completes successfully (green checkmark), your app is live! Any future push to main will trigger this process automatically.

---

Scenario 3: Containerized Deployment with Docker (Advanced)

Containers package your app and its dependencies into a single, portable unit. This ensures consistency across all environments ("it works on my machine" is no longer an excuse).

Step 1: Add Docker Support

1. Right-click on your ASP.NET Core project in Visual Studio.

2. Select Add > Docker Support.... Choose Linux as the OS.

This creates a Dockerfile in your project root. This is the recipe for building your image.

Example Dockerfile (What VS creates):

dockerfile

# See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
USER app
WORKDIR /app
EXPOSE 8080
EXPOSE 8081

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["MyFirstAzureWebApp/MyFirstAzureWebApp.csproj", "MyFirstAzureWebApp/"]
RUN dotnet restore "./MyFirstAzureWebApp/MyFirstAzureWebApp.csproj"
COPY . .
WORKDIR "/src/MyFirstAzureWebApp"
RUN dotnet build "./MyFirstAzureWebApp.csproj" -c $BUILD_CONFIGURATION -o /app/build

FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./MyFirstAzureWebApp.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyFirstAzureWebApp.dll"]

Step 2: Build and Test Locally

1. Ensure Docker Desktop is running.

2. In Visual Studio, set the launch dropdown to Docker and hit F5. Your app will run inside a local container!

Step 3: Deploy to Azure Container Registry (ACR)

1. Create an Azure Container Registry in your Azure portal.

2. Build your image and push it to ACR. You can do this with Azure CLI commands:

   bash

   az acr build --registry <your-acr-name> --image myaspnetapp:v1 .

   This command builds the image directly in the cloud.

Step 4: Configure App Service for Containers

1. In the Azure Portal, create a new Web App.

2. In the Basics tab, choose:

   • Publish: Docker Container

   • Operating System: Linux

3. In the Docker tab, configure:

   • Options: Single Container

   • Image Source: Azure Container Registry

   • Select your Registry and Image (myaspnetapp:v1).

4. Create the app. It will now pull and run your container image!

---

Best Practices & Gotchas

• Never Store Secrets in appsettings.json: Use Azure App Configuration or the App Service Configuration blade to set connection strings and secrets as environment variables. They override anything in your config files.

• Use Deployment Slots: Create a staging deployment slot. Deploy your new version to staging first, test it, and then "swap" it with production. This ensures zero-downtime deployments and easy rollbacks.

• Configure Logging: Enable Application Logging (Filesystem) and App Service Logs in the Azure Portal. It's your first line of defense for troubleshooting a failed deployment or runtime error.

• Custom Domains & SSL: Easily add a custom domain and get a free SSL certificate provided by Azure directly from the App Service TLS/SSL settings.

• Monitor Performance: Use Azure Application Insights (built into Visual Studio's publish wizard) to get deep insights into your app's performance, usage, and failures.

Conclusion

You've just graduated from deploying simple apps to setting up automated, professional-grade deployment pipelines! Azure App Service removes the heavy lifting of infrastructure management, allowing you to focus on what you do best: writing great code.

Whether you choose the simplicity of right-click publish, the power of GitHub Actions, or the consistency of Docker containers, you have a robust path to get your ASP.NET Core application into the hands of users around the world.

📘Free Job Preparation Zone 🎯 Visit Free Learning Zone