CI/CD for .NET: GitHub Actions vs Azure DevOps - Complete Comparison 2025

Architecture and Core Concepts

GitHub Actions uses a four-layer architecture: Events (triggers),Workflows (.yml files), Jobs (parallel execution units), and Steps (individual tasks). Workflows live in your repository at.github/workflows/.

Architecture and Services

Azure DevOps provides five integrated services that work together or independently:

Migration Strategy

1. Inventory Phase: Document all pipelines, triggers, service connections, variable groups, and deployment targets in Azure DevOps
2. Pilot Pipeline: Choose a non-critical application and migrate its pipeline first. Run both pipelines in parallel for 1-2 weeks to validate
3. Secrets & Variables: Migrate secrets to GitHub Secrets, variables to GitHub Environment Variables. Use Dependabot for automated secret rotation
4. Service Connections: Replace Azure DevOps service connections with GitHub OIDC (OpenID Connect) for passwordless authentication to Azure
5. Batch Migration: Migrate remaining pipelines in batches, grouped by team or service. Maintain Azure DevOps as backup for 30 days
6. Decommission: After validation period, decommission Azure DevOps pipelines. Keep Boards/Test Plans if needed

Common Pattern Conversions

trigger:
  branches:
    include:
      - main
      - develop

on:
  push:
    branches:
      - main
      - develop

variables:
  buildConfiguration: 'Release'
  dotnetVersion: '8.0.x'

env:
  BUILD_CONFIGURATION: 'Release'
  DOTNET_VERSION: '8.0.x'

- task: UseDotNet@2
  inputs:
    version: '8.0.x'
- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    projects: '**/*.csproj'

- uses: actions/setup-dotnet@v4
  with:
    dotnet-version: '8.0.x'
- run: dotnet build --configuration Release

GitHub Actions: .NET 8 Web API to Azure App Service

File: .github/workflows/deploy-api.yml

name: Deploy .NET API to Azure

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  workflow_dispatch:

env:
  DOTNET_VERSION: '8.0.x'
  AZURE_WEBAPP_NAME: 'my-api-prod'
  WORKING_DIRECTORY: './src/MyApi'

permissions:
  id-token: write  # Required for OIDC
  contents: read

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

    steps:
    - uses: actions/checkout@v4

    - name: Setup .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: Restore dependencies
      run: dotnet restore
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Build
      run: dotnet build --no-restore --configuration Release
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Run unit tests
      run: dotnet test --no-build --configuration Release --logger "trx" --collect:"XPlat Code Coverage"
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Publish
      run: dotnet publish --no-build --configuration Release --output ./publish
      working-directory: ${{ env.WORKING_DIRECTORY }}

    - name: Upload artifact
      uses: actions/upload-artifact@v4
      with:
        name: api-package
        path: ${{ env.WORKING_DIRECTORY }}/publish
        retention-days: 7

  deploy-production:
    needs: build-and-test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    environment:
      name: production
      url: https://my-api-prod.azurewebsites.net

    steps:
    - name: Download artifact
      uses: actions/download-artifact@v4
      with:
        name: api-package
        path: ./publish

    - name: Azure Login (OIDC)
      uses: azure/login@v2
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Deploy to Azure Web App
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ./publish

    - name: Health Check
      run: |
        sleep 30  # Wait for app to start
        response=$(curl -s -o /dev/null -w "%{http_code}" https://my-api-prod.azurewebsites.net/health)
        if [ $response -ne 200 ]; then
          echo "Health check failed with status $response"
          exit 1
        fi
        echo "Deployment successful, health check passed"

Key features: Separate build/deploy jobs, artifact caching, OIDC authentication (no secrets!), environment protection rules, health check validation.

Azure DevOps: .NET 8 Web API to Azure App Service

File: azure-pipelines.yml

trigger:
  branches:
    include:
      - main

pr:
  branches:
    include:
      - main

variables:
  dotnetVersion: '8.0.x'
  buildConfiguration: 'Release'
  azureSubscription: 'MyAzureServiceConnection'
  webAppName: 'my-api-prod'
  workingDirectory: './src/MyApi'

stages:
- stage: Build
  displayName: 'Build and Test'
  jobs:
  - job: BuildJob
    displayName: 'Build .NET API'
    pool:
      vmImage: 'ubuntu-latest'

    steps:
    - task: UseDotNet@2
      displayName: 'Install .NET SDK'
      inputs:
        version: $(dotnetVersion)
        packageType: 'sdk'

    - task: DotNetCoreCLI@2
      displayName: 'Restore NuGet packages'
      inputs:
        command: 'restore'
        projects: '$(workingDirectory)/**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: 'Build solution'
      inputs:
        command: 'build'
        projects: '$(workingDirectory)/**/*.csproj'
        arguments: '--configuration $(buildConfiguration) --no-restore'

    - task: DotNetCoreCLI@2
      displayName: 'Run unit tests'
      inputs:
        command: 'test'
        projects: '$(workingDirectory)/**/*Tests.csproj'
        arguments: '--configuration $(buildConfiguration) --no-build --collect:"XPlat Code Coverage"'

    - task: DotNetCoreCLI@2
      displayName: 'Publish application'
      inputs:
        command: 'publish'
        publishWebProjects: false
        projects: '$(workingDirectory)/MyApi.csproj'
        arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
        zipAfterPublish: true

    - task: PublishBuildArtifacts@1
      displayName: 'Publish artifacts'
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'api-package'

- stage: Deploy
  displayName: 'Deploy to Production'
  dependsOn: Build
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployWeb
    displayName: 'Deploy to Azure App Service'
    pool:
      vmImage: 'ubuntu-latest'
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: DownloadBuildArtifacts@1
            displayName: 'Download artifacts'
            inputs:
              buildType: 'current'
              downloadType: 'single'
              artifactName: 'api-package'
              downloadPath: '$(System.ArtifactsDirectory)'

          - task: AzureWebApp@1
            displayName: 'Deploy to Azure Web App'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appName: '$(webAppName)'
              package: '$(System.ArtifactsDirectory)/api-package/*.zip'
              deploymentMethod: 'zipDeploy'

          - task: AzureCLI@2
            displayName: 'Health check'
            inputs:
              azureSubscription: '$(azureSubscription)'
              scriptType: 'bash'
              scriptLocation: 'inlineScript'
              inlineScript: |
                sleep 30
                response=$(curl -s -o /dev/null -w "%{http_code}" https://my-api-prod.azurewebsites.net/health)
                if [ $response -ne 200 ]; then
                  echo "Health check failed with status $response"
                  exit 1
                fi
                echo "Deployment successful, health check passed"

Key features: Multi-stage pipeline (build/deploy separation), deployment job with environment tracking, service connection for Azure, artifact management, health check validation.

Application Profile

• Type: E-commerce backend API (.NET 8, ASP.NET Core Minimal APIs)
• Infrastructure: Azure App Service (3 instances, P2v3 tier)
• Database: Azure SQL Database (S3 tier)
• Team: 8 developers, ~40 commits/day, 15-20 deployments/day
• Testing: 1,200 unit tests, 150 integration tests