Azure Pipelines Automated Deployment (Git + ASP.NET Core)

flowchart LR
    A[Developer] --> |Push| B("Repository (Git)")
    B -.-> C(Azure Pipelines)
    C --> |Deploy| D(Execution Environment) 

1Creating a Service Connection

First, you need to create a Service Connection.
A Service Connection is an authenticated connection setting that allows Azure DevOps pipelines to access external services. External services refer to resources such as GitHub repositories or Azure App Services. Since Azure is considered an external service from Azure DevOps' perspective, a connection setting is required.

flowchart LR
    A[Azure DevOps] -->|Service Connection| B(Azure App Service)

Click Project Settings > Service connections > New service connection in your project, then select Azure Resource Manager and click Next (Figure 2).

Figure 2. Selecting the Service Connection type

Configure the Service connection details (Figure 3).

Figure 3. Service Connection settings

• Select Subscription
• Select Resource group
  Select the resource group of the target App Service for deployment.
• Enter Service Connection Name
  A name to identify the Service Connection (here, "Service Connection").
• Check "Grant access permission to all pipelines"
  This allows all pipelines to use this Service Connection.
  If you want to control permissions on a per-pipeline basis, leave it unchecked.

Leave other settings at their default values and click the "Save" button.
*Items below Resource group can be changed later.

This completes the creation of the Service Connection.

2Creating an Azure Pipeline

Next, we will create the pipeline definition file (YAML file) that executes the deployment.

Navigate to Pipelines > Create Pipeline > Azure Repos Git (Figure 4) > Select your repository.

Figure 4. Selecting the repository type

In "Configure your pipeline", select ASP.NET Core. (Figure 5)
It can be confusing, but make sure to select the one that says ASP.NET Core, not ASP.NET or ASP.NET Core (.NET Framework).

Figure 5. Configure your pipeline

A template YAML file will be displayed (Figure 6).

Figure 6. Review your pipeline YAML

Without changing the content, click the "Save and run" button in the upper right.
A dialog for entering a commit message will appear (Figure 7).

Figure 7. Save and run

Clicking "Save and run" here will add a YAML file named azure-pipelines.yml to the root folder of the existing repository and push it to the repository.
Click "Save and run".

After a short while, a pipeline execution screen like the one below will appear (Figure 8).
The "Status" field at the bottom shows "Queued". This indicates that the pipeline execution request has been added to the queue but has not yet started.

Figure 8. Queued

Let's wait.
After a while, the Status will change to "Running" and finally to "Success".
A green checkmark will be displayed in the background.
This indicates that the pipeline execution has completed successfully (Figure 9).

Figure 9. Success

3Contents of the YAML File

Has deployment been performed through the steps so far? No, it hasn't.
Only the build was executed. Let's take a closer look at the content of the template YAML file.

# ASP.NET Core
# Build and test ASP.NET Core projects targeting .NET Core.
# Add steps that run tests, create a NuGet package, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/dotnet-core

trigger:
- main

pool:
  vmImage: ubuntu-latest

variables:
  buildConfiguration: 'Release'

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

trigger section

trigger:
- main

This pipeline will automatically run when a push occurs to the main branch.

pool section

pool:
  vmImage: ubuntu-latest

Specifies the virtual machine image to run the pipeline.
ubuntu-latest refers to the latest Ubuntu environment.
Since this is a virtual machine for running the pipeline, it does not need to match the OS of the deployment target.

flowchart LR
    A(Azure Pipeline) -.-> B[Virtual Machine]
    B --> |Deploy| C(Execution Environment) 

variables section

variables:
  buildConfiguration: 'Release'

The variables section allows you to define variables that can be referenced within the pipeline.
The variable here is:

• Variable name: $(buildConfiguration)
• Value: Release

steps section

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

The steps section describes the commands (script) or tasks (task) (steps) to be executed in the pipeline.

• The dotnet build command builds the project.
  The --configuration option specifies Release mode.
• displayName is the label displayed in the Azure DevOps UI.
  Since the value of $(buildConfiguration) is Release, it will display as dotnet build Release.

Where is this label displayed?
Clicking the Job row in Figure 8 and Figure 9 navigates to the detailed screen of the pipeline execution.
The execution details of each process within the pipeline are displayed here, and displayName is shown here (Figure 10).

Figure 10. Details screen

4Adding a Publish Task

As seen so far, the current YAML file only defines settings up to the build.
Let's add the deployment settings.

To perform a deployment, you need to collect and package the files as artifacts for deployment.
This is known as "publishing".
Here, the artifacts are compressed into a single zip file.

You can add a publish task from the Azure Pipeline GUI.
Select the three dots in the upper right corner of Figure 8, Figure 9 > Edit pipeline.
To add code to the end of the YAML file, place the cursor on the last line and then select .NET Core under Tasks (Figure 11).
(If Tasks is not displayed, click Show assistant in the upper right.)

Figure 11. Selecting a Task

Enter the following (Figure 12).

Figure 12. .NET Core

• Command: publish
• Arguments: --configuration $(buildConfiguration)
  This will build in Release mode.

Leave all other settings as default and click the "Add" button.
The publish task code will be added as shown below (Figure 13).

Figure 13. Publish task code added

This completes the addition of the publish task.

5Adding a Deploy Task

Following the same process as in (4), place the cursor on the last line of the YAML and then select Azure Web App under Tasks (Figure 14).

Figure 14. Selecting a Task

Select the details of the deployment target (Figure 15).

Figure 15. Azure Web App

• Azure subscription
  Select the Service Connection created in (1).
• App type
  Select the type of deployment target (Windows/Linux).
• App name
  Select the target App Service for deployment.

Leave other settings at their default values and click the "Add" button.
The task code to execute the deployment will be added as shown below (Figure 16).

Figure 16. Deploy task code added

6Executing the Deployment

All necessary settings for deployment have been completed up to this point.
Click the "Validate and save" button (Figure 17).

Figure 17. Validate and save

Click the "Save" button (Figure 18).

Figure 18. Validate and save

The screen will automatically transition to the pipeline execution view (Figure 19).

Figure 19. Pipeline running

After a short wait, the pipeline execution will complete (Figure 20).
This completes the deployment.

Figure 20. Pipeline execution complete

# ASP.NET Core
# Build and test ASP.NET Core projects targeting .NET Core.
# Add steps that run tests, create a NuGet package, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/dotnet-core

trigger:
- main

pool:
  vmImage: ubuntu-latest

variables:
  buildConfiguration: 'Release'

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration)'

- task: AzureWebApp@1
  inputs:
    azureSubscription: 'Service Connection'
    appType: 'webAppLinux'
    appName: 'korochin-hoge'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

trigger:
- main

pool:
  vmImage: ubuntu-latest

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true

- task: AzureWebApp@1
  inputs:
    azureSubscription: 'Service Connection'
    appType: 'webAppLinux'
    appName: 'korochin-hoge'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'