In today’s fast-paced tech environment, ensuring your applications are continuously deployed and seamlessly integrated is crucial. One effective way to achieve this for your .NET Core projects is by using GitHub Actions to set up a CI/CD pipeline. This article provides a comprehensive guide on configuring a CI/CD pipeline using GitHub Actions for a .NET Core project, leveraging the power of Azure.
Setting Up Your GitHub Repository
To start building your CI/CD pipeline, you need a GitHub repository to host your .NET Core project. Creating and configuring this repository properly ensures a smooth workflow when integrating GitHub Actions.
Creating the Repository
Navigate to GitHub and create a new repository. Ensure that you initialize the repository with a README file and a .gitignore file tailored for .NET projects. This .gitignore file helps keep unnecessary files out of your repository, focusing only on essential components.
Adding Your .NET Core Project
Clone the repository to your local machine and add your .NET Core project files. Use the following commands in your terminal:
git clone https://github.com/your-username/your-repository.git
cd your-repository
dotnet new webapp -n YourProjectName
git add .
git commit -m "Initial commit with .NET Core project"
git push origin main
This sets up your project structure in the repository. Ensure your project builds locally before proceeding to avoid potential issues during CI/CD configuration.
Configuring GitHub Actions
GitHub Actions allows you to automate workflows directly within your repository. For a .NET Core project, you can configure actions to build, test, and deploy your application.
Creating the Workflow File
In your repository, create a .github/workflows directory. Inside this directory, create a YAML file named ci-cd-pipeline.yml. This file defines the steps and jobs for your CI/CD pipeline.
Defining the Workflow
Your ci-cd-pipeline.yml file should start with the following:
name: CI/CD Pipeline
on:
push:
branches:
- main
pull_request:
branches:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Setup .NET Core
uses: actions/setup-dotnet@v1
with:
dotnet-version: '6.0.x'
- name: Restore dependencies
run: dotnet restore
- name: Build the project
run: dotnet build --configuration Release --no-restore
...
This setup triggers the workflow upon pushes and pull requests to the main branch. The job runs on an Ubuntu machine, indicating the build environment. Each step specifies a task, from checking out the code to building the project.
Securing Secrets and Setting Environments
To deploy your application to Azure, you’ll need to secure sensitive information and configure environment variables.
Managing Secrets
GitHub allows you to store secrets securely, such as Azure credentials and publish profiles. In your repository settings, find the “Secrets and variables” section and add the following secrets:
AZURE_CREDENTIALS: Your Azure service principal credentials.AZURE_WEBAPP_PUBLISH_PROFILE: The publish profile for your Azure Web App.
Configuring the Environment Variables
Modify your workflow file to use these secrets:
- name: Deploy to Azure Web App
uses: Azure/webapps-deploy@v2
with:
app-name: 'YourWebAppName'
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: .
This ensures your deployment process uses the secure credentials you set up in your repository.
Deploying Your .NET Core Application to Azure
Deploying your application involves pushing your build to an Azure Web App. This section outlines the steps to automate this process using GitHub Actions.
Prerequisites
Before you start, ensure you have an Azure account and an Azure Web App ready. You can create a new Web App in the Azure portal if needed.
Update the Workflow for Deployment
Expand the ci-cd-pipeline.yml file to include deployment steps:
deploy:
runs-on: ubuntu-latest
needs: build
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Setup .NET Core
uses: actions/setup-dotnet@v1
with:
dotnet-version: '6.0.x'
- name: Publish project
run: dotnet publish -c Release -o ${{ github.workspace }}/publish
- name: Deploy to Azure Web App
uses: azure/webapps-deploy@v2
with:
app-name: 'YourWebAppName'
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: ${{ github.workspace }}/publish
This configuration sets up a deployment job that runs after the build job. It publishes the project and deploys it to your Azure Web App using the provided package path.
Verifying the Deployment
Once you push changes to the main branch or create a pull request, the workflow initiates. Monitor the Actions tab in your GitHub repository to follow the build and deployment process. Upon successful deployment, your .NET Core application should be live on Azure.
Setting up a CI/CD pipeline using GitHub Actions for a .NET Core project involves orchestrating various steps, from configuring your repository to deploying your application on Azure. By following this guide, you’ve learned how to leverage GitHub Actions to automate builds, tests, and deployments, ensuring your .NET Core applications are continuously integrated and deployed efficiently. This streamlined process not only enhances productivity but also ensures that your application consistently meets quality standards, ready for users on demand.
