Setting Up CI/CD Pipelines for .NET Core Applications on Azure

In today’s fast-paced development environment, the need for efficient deployment processes is paramount. Continuous Integration (CI) and Continuous Deployment (CD) pipelines are vital for automating the build and release of applications, allowing developers to focus on coding rather than manual processes. In this article, we’ll explore how to set up CI/CD pipelines for .NET Core applications on Azure, providing you with actionable insights, code examples, and troubleshooting tips along the way.

What is CI/CD?

Continuous Integration (CI)

Continuous Integration is a development practice that encourages developers to integrate code into a shared repository frequently. Each integration is verified by an automated build and tests, allowing teams to detect problems early.

Continuous Deployment (CD)

Continuous Deployment goes a step further by automatically deploying every code change that passes the automated testing phase to production. This ensures that your application is always up-to-date with the latest features and bug fixes.

Why Use CI/CD for .NET Core Applications?

• Faster Release Cycles: Automating the integration and deployment processes reduces the time it takes to deliver new features.
• Improved Code Quality: Automated tests catch bugs early, leading to higher-quality code.
• Scalability: CI/CD pipelines can handle growing project complexity with ease.
• Collaboration: Encourages team collaboration by integrating changes frequently.

Prerequisites for Setting Up CI/CD on Azure

Before diving into the setup process, ensure you have the following:

• An Azure account: Sign up if you don’t already have one.
• .NET Core SDK: Make sure you have the latest version installed.
• A GitHub repository: This will host your source code.

Step-by-Step Guide to Setting Up CI/CD Pipelines

Step 1: Create a .NET Core Application

First, let’s create a simple .NET Core application. Open your terminal and run:

dotnet new webapp -n MyWebApp
cd MyWebApp
dotnet run

You should see your application running at http://localhost:5000.

Step 2: Push to GitHub

Initialize a Git repository and push your application to GitHub:

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/YOUR_USERNAME/MyWebApp.git
git push -u origin master

Step 3: Set Up Azure DevOps

1. Create a new Azure DevOps project:

2. Navigate to Azure DevOps and create a new project.

3. Connect to GitHub:

4. Go to your project settings, then under "Service connections", set up a new connection to GitHub.

5. Create a new pipeline:

6. In Azure DevOps, go to Pipelines > Pipelines > New Pipeline.
7. Select GitHub as the source and authorize Azure DevOps to access your repository.

Step 4: Configure the CI/CD Pipeline

YAML Configuration

You can define your CI/CD pipeline using a YAML file. Create a file named azure-pipelines.yml in the root of your repository with the following content:

trigger:
- master

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '6.x'
    installationPath: $(Agent.ToolsDirectory)/dotnet

- script: dotnet build --configuration Release
  displayName: 'Build project'

- script: dotnet test --no-build --verbosity normal
  displayName: 'Run tests'

- task: AzureWebApp@1
  inputs:
    azureSubscription: 'YOUR_AZURE_SUBSCRIPTION'
    appType: 'webApp'
    webAppName: 'YOUR_WEB_APP_NAME'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

Step 5: Set Up Azure Web App

1. Create a Web App:

2. Go to the Azure portal, navigate to "App Services," and create a new Web App. Choose the runtime stack as .NET Core.

3. Configure deployment settings:

4. In the "Deployment Center," select Azure DevOps and link it to your pipeline.

Step 6: Triggering the Pipeline

Now that everything is set up, make a change to your code, commit it, and push it to GitHub. This action will trigger the CI/CD pipeline:

echo "// New feature" >> index.cshtml
git add index.cshtml
git commit -m "Added a new feature"
git push

Step 7: Monitor the Pipeline

In Azure DevOps, navigate to Pipelines > Pipelines to monitor the build and release stages. You can see logs for each step, which can help in troubleshooting if something goes wrong.

Troubleshooting Common Issues

• Build Failures: Check the logs for specific error messages. Ensure that all dependencies are correctly referenced.
• Deployment Errors: Make sure that the Azure Web App settings are correctly configured and that the correct subscription is selected in your pipeline.
• Test Failures: Review the test logs to identify failing tests. Ensure your test project is included in the solution.

Conclusion

Setting up CI/CD pipelines for .NET Core applications on Azure can significantly streamline your development process. By following this guide, you’ve learned how to create a simple application, push it to GitHub, and automate its build and deployment using Azure DevOps. This not only helps in delivering features faster but also improves the overall quality of your applications. Start implementing CI/CD practices today, and take your development workflow to the next level!