ASP.NET Core

CI/CD Pipeline for ASP.NET Core Using Azure DevOps

A CI/CD pipeline automates the process of building, testing, and deploying an ASP.NET Core application. Instead of manually publishing code, Azure DevOps automatically runs builds and deployments whenever code is pushed to the repository. This improves development speed, reduces human errors, and ensures consistent releases.

What is Continuous Integration (CI)?

Continuous Integration means that whenever a developer pushes code to the main branch, Azure DevOps automatically:

  • Restores NuGet packages

  • Builds the ASP.NET Core project

  • Runs unit tests

  • Generates build artifacts

If any step fails (for example, a test case fails), the pipeline stops. This ensures only stable code moves forward.

What is Continuous Deployment (CD)?

Continuous Deployment means automatically deploying the successfully built application to environments like:

  • Development

  • QA / Testing

  • Staging

  • Production

Azure DevOps supports YAML pipelines, which allow defining the full CI/CD process as code. Applications can be deployed to:

  • Azure App Service

  • Azure Virtual Machines

  • Azure Kubernetes Service (AKS)

  • Docker Containers

Complete CI/CD Flow

  1. Developer pushes code to Azure Repos or GitHub.

  2. CI pipeline triggers automatically.

  3. Project is restored, built, and tested.

  4. Build artifacts are published.

  5. CD pipeline deploys the application to Azure.

Sample YAML Pipeline (ASP.NET Core .NET 8)

trigger:
- main

pool:
  vmImage: 'windows-latest'

variables:
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '8.0.x'

- script: dotnet restore
  displayName: Restore Dependencies

- script: dotnet build --configuration $(buildConfiguration)
  displayName: Build Project

- script: dotnet test --configuration $(buildConfiguration)
  displayName: Run Unit Tests

- script: dotnet publish -c $(buildConfiguration) -o $(Build.ArtifactStagingDirectory)
  displayName: Publish Application

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)'
    artifactName: 'drop'

Adding Deployment Stage (Example for Azure App Service)

You can extend the pipeline with stages:

stages:
- stage: Build
  jobs:
  - job: BuildJob
    steps:
      # Build steps here

- stage: Deploy
  dependsOn: Build
  jobs:
  - deployment: DeployWeb
    environment: 'Dev'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              azureSubscription: 'Your-Service-Connection'
              appName: 'your-app-name'
              package: '$(Pipeline.Workspace)/drop/*.zip'

Best Practices

  • Use separate environments (Dev, QA, Prod)

  • Enable branch policies (PR validation)

  • Use Azure Key Vault for secrets

  • Add code quality tools (SonarQube)

  • Enable approval gates before production deployment

  • Use Infrastructure as Code (Bicep / Terraform)

Benefits of CI/CD

  • Faster and reliable releases

  • Automated testing and validation

  • Reduced manual deployment errors

  • Improved collaboration between teams

  • Better code quality and monitoring

Conclusion

Using Azure DevOps CI/CD pipelines for ASP.NET Core applications ensures automation, quality, and scalability. By defining the pipeline in YAML, teams can version-control their deployment process and maintain a consistent release strategy. This approach makes applications production-ready and supports modern DevOps practices.
Membership not found