Skip to main content

.NET Azure Deployment

In today's cloud-first world, deploying applications to cloud platforms has become essential knowledge for developers. Microsoft Azure offers robust hosting solutions for .NET applications, providing scalability, reliability, and a wide range of services to enhance your applications.

Introduction to Azure Deployment​

Microsoft Azure is a cloud computing platform that allows you to build, deploy, and manage applications through Microsoft's global network of data centers. For .NET developers, Azure provides a natural extension of the development environment, offering seamless integration with Visual Studio and the .NET ecosystem.

In this guide, we'll explore various approaches to deploy .NET applications to Azure, from simple web apps to more complex microservice architectures.

Prerequisites​

Before we begin, ensure you have:

  1. An active Azure subscription (You can create a free account)
  2. .NET SDK installed
  3. Azure CLI installed
  4. Visual Studio or Visual Studio Code with Azure extensions

Deployment Options for .NET Applications in Azure​

Azure offers multiple options for hosting .NET applications:

  1. Azure App Service: Platform-as-a-Service (PaaS) for web applications
  2. Azure Functions: Serverless compute service for event-driven applications
  3. Azure Kubernetes Service (AKS): Managed Kubernetes for containerized applications
  4. Azure Container Instances: For running containers without managing servers
  5. Azure Virtual Machines: Infrastructure-as-a-Service (IaaS) for full control

We'll focus on the most common options for beginners: App Service and Azure Functions.

Deploying to Azure App Service​

Azure App Service is a fully managed platform for building, deploying, and scaling web apps. It's perfect for most .NET web applications.

Creating a Simple .NET Web Application​

Let's start by creating a simple .NET web application:

bash
dotnet new webapp -n MyFirstAzureApp
cd MyFirstAzureApp
dotnet build
dotnet run

This will create and run a basic ASP.NET Core web application. Visit https://localhost:5001 in your browser to see it in action.

Deploying via Visual Studio​

  1. Right-click on your project in Solution Explorer
  2. Select Publish
  3. Choose Azure as the target
  4. Select Azure App Service (Windows) or (Linux)
  5. Follow the wizard to create a new App Service or select an existing one
  6. Click Publish

Visual Studio will package your application, upload it to Azure, and open the deployed site in your browser.

Deploying via Azure CLI​

For a more script-based approach:

  1. Build your application:
bash
dotnet publish -c Release
  1. Login to Azure:
bash
az login
  1. Create a resource group (if you don't have one):
bash
az group create --name myResourceGroup --location eastus
  1. Create an App Service plan:
bash
az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku F1
  1. Create a web app:
bash
az webapp create --name myUniqueAppName --resource-group myResourceGroup --plan myAppServicePlan --runtime "dotnet:7"
  1. Deploy your application:
bash
cd bin/Release/net7.0/publish
zip -r site.zip .
az webapp deployment source config-zip --resource-group myResourceGroup --name myUniqueAppName --src site.zip

After deployment, your app will be available at https://myUniqueAppName.azurewebsites.net.

Deploying via GitHub Actions​

For continuous deployment using GitHub:

  1. Push your code to a GitHub repository
  2. In the Azure Portal, navigate to your App Service
  3. Go to Deployment Center
  4. Select GitHub as the source
  5. Configure repository, branch, and build settings
  6. Click Save

Now your application will automatically deploy whenever you push changes to the selected branch.

Here's a sample GitHub Actions workflow file (.github/workflows/azure-deploy.yml):

yaml
name: Deploy to Azure
on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '7.0.x'
    
    - name: Build and publish
      run: |
        dotnet restore
        dotnet build --configuration Release
        dotnet publish -c Release -o './publish'
        
    - name: Deploy to Azure
      uses: azure/webapps-deploy@v2
      with:
        app-name: 'myUniqueAppName'
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: './publish'

Deploying to Azure Functions​

Azure Functions allows you to run small pieces of code (functions) without worrying about application infrastructure.

Creating a .NET Azure Function​

  1. Create a new Function App:
bash
dotnet new func -n MyFunctionApp
cd MyFunctionApp
  1. Add a HTTP-triggered function:
bash
func new --name HelloAzure --template "HTTP trigger" --authlevel "function"
  1. Test locally:
bash
func start
  1. Create a Function App in Azure:
bash
az functionapp create --resource-group myResourceGroup \
--consumption-plan-location eastus \
--runtime dotnet --functions-version 4 \
--name myUniqueFunctionApp \
--storage-account mystorageaccount
  1. Deploy:
bash
func azure functionapp publish myUniqueFunctionApp

After deployment, your function will be available at https://myUniqueFunctionApp.azurewebsites.net/api/HelloAzure?code=....

Containerized .NET Applications on Azure​

For more complex applications, containerization offers consistency across environments.

Containerizing a .NET Application​

  1. Create a Dockerfile in your project:
dockerfile
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]
  1. Build the Docker image:
bash
docker build -t myapp:latest .
  1. Deploy to Azure Container Registry:
bash
az acr create --resource-group myResourceGroup --name myUniqueRegistry --sku Basic
az acr login --name myUniqueRegistry
docker tag myapp:latest myUniqueRegistry.azurecr.io/myapp:latest
docker push myUniqueRegistry.azurecr.io/myapp:latest
  1. Deploy to Azure App Service:
bash
az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name myUniqueAppName --deployment-container-image-name myUniqueRegistry.azurecr.io/myapp:latest

Real-World Example: Deploying a Multi-Tier .NET Application​

Let's consider a more complex scenario: a web application with a SQL database backend.

Step 1: Create an Azure SQL Database​

bash
# Create SQL Server
az sql server create --name myUniqueSqlServer \
--resource-group myResourceGroup \
--location eastus \
--admin-user serveradmin \
--admin-password P@ssw0rd1234

# Create Database
az sql db create --resource-group myResourceGroup \
--server myUniqueSqlServer \
--name MyDatabase \
--service-objective S0

Step 2: Update Your Connection String​

In your appsettings.json:

json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=tcp:myUniqueSqlServer.database.windows.net,1433;Initial Catalog=MyDatabase;Persist Security Info=False;User ID=serveradmin;Password=P@ssw0rd1234;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
  }
}

Step 3: Deploy the Web Application​

Follow the App Service deployment steps covered earlier.

Step 4: Configure Network Security​

bash
# Allow Azure services to access the SQL server
az sql server firewall-rule create --resource-group myResourceGroup \
--server myUniqueSqlServer \
--name AllowAzureServices \
--start-ip-address 0.0.0.0 \
--end-ip-address 0.0.0.0

Best Practices for Azure Deployment​

  1. Use Configuration Management: Leverage Azure App Configuration or Key Vault for secrets
  2. Implement Monitoring: Set up Application Insights for performance monitoring
  3. Plan for Scaling: Configure auto-scaling rules based on metrics
  4. Secure Your Application: Implement Azure AD authentication and HTTPS
  5. Use Deployment Slots: Test changes in staging before swapping to production
  6. Automate Deployments: Use CI/CD pipelines with Azure DevOps or GitHub Actions

Troubleshooting Common Issues​

Application Won't Start​

Check the logs using:

bash
az webapp log tail --name myUniqueAppName --resource-group myResourceGroup

Connection Issues with Database​

Verify firewall settings and connection strings.

Slow Performance​

Enable Application Insights and examine performance metrics.

Summary​

In this guide, we've explored various approaches to deploy .NET applications to Azure:

  • Deploying web applications using Azure App Service
  • Creating serverless applications with Azure Functions
  • Containerizing .NET applications for deployment
  • Setting up a multi-tier application with a database backend

Azure provides a robust and flexible platform for hosting .NET applications of all sizes and complexities. By following the best practices outlined in this guide, you can ensure reliable, scalable, and secure deployments.

Additional Resources​

Exercises​

  1. Deploy a basic .NET web API to Azure App Service
  2. Create an Azure Function that processes data from Azure Storage
  3. Set up a CI/CD pipeline using GitHub Actions or Azure DevOps
  4. Implement Azure AD authentication for your web application
  5. Configure auto-scaling for your App Service based on CPU usage

By mastering these deployment techniques, you'll be well-equipped to leverage Azure's powerful features for your .NET applications and advance your cloud development skills.


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)