In previous post, we´ve discussed about the docker build and publish tasks in the Azure DevOps pipeline.

In this post we will add the final tasks to pipeline and setup triggers to execute the pipeline automatically, enabling the continuous integration.

Tag your code

Your pipeline is almost ready, the last task to add is tag your source code. Go to Get Sources task and change the Tag Sources property to On success. You can also customize the tag format, but is a good idea to use the $(build.buildNumber) pipeline variable, because the tag must be a unique name.

Your pipeline task are now ready, you need to add a trigger to start the pipeline automatically during continuous integration of your code. To do this, click on Triggers menu. Then enable the continuous integration trigger and select which branch you want to monitor (in this example branch master).

To test your pipeline you can simply do a pull request from a branch to master and the pipeline will start automatically. The pipeline results will be as follow:

Pipeline logs: It shows all executed steps of your pipeline, if you click in each step, a detailed log will be shown.

Tests results: The tests resuls page will show all tests executed in your test project, if a test fails, it will appear in a list and also the reason the test has failed.

Summary page: The summary page is responsible for showing all linked information in your pipeline, since the commits made, until deployments (in this case the deployment does not exists).

Also you can check the SonarQube Analysis result of analysis. You can also click on Detailed SonarQube report and you will be redirected to the SonarQube project page:

In this page you have all information regarding bugs, vulnerabilities, code smells and the code coverage.

If look to your repository you will see a new tag in GitHub:

Now everytime you commit a code and your pull request is approved to the master branch (or the branch you defined as trigger) will start the build pipeline, analyzing, testing and publishing your image wherever your need.

For any doubts just leave a comment.

Cheers!

In part 2, we added code analysis and tests tasks to the build pipeline, now it´s time to build the application and publish it to docker hub.

To build an Docker image, you need to create a Docker file and write the steps to mount your image. In the example, the Docker file is responsible for download the net core sdk image to build the image and download a net core runtime sdk to run the application within.

You can use your own Docker file or use the file from this repository as template.

Back to pipeline, add a new task, by clicking the + button on agent job. Search for Docker, select the Docker task and add to your pipeline. The default action will build the image and push to the container registry.

Once the task is placed, select a container registry connection, this is the place you will publish your image. The container registry can be a Docker Hub, Azure Container Registry or others. In this post we are using Docker Hub as container registry. For first time you need to add a connection to Docker Hub account Add a new connection and fill the properties of connection:

On container repository property, write the name of image you want to create. The user account on Docker Hub must preeced the image name, otherwise, a access denied error will be thrown.

When the pipeline runs, the Docker task will build the image based on the Dockerfile file and will publish the image to your Docker hub account. One important thing is the image tag, this property will set the image version of your Docker image. Change the default value $(Build.BuildId) to $(Build.BuildNumber) pipeline variable. This variable represents the build id number and is unique for each build.

Now your pipeline is ready to build your application and publish to the docker hub registry. In the next and final post we will add a final task, set the pipeline trigger and test it.

In this series, I will guide you to create a complete CI (build) pipeline in Azure DevOps, covering all necessary aspects to build a full net core application (an API service), and deploying to docker hub.

The aspects covered in this series are:

• Get source code from GitHub
• Code Analysis
• Unit Tests
• Unit Tests coverage
• Build DockerFile
• Push DockerFile to DockerHub
• Publish artifacts for CD pipeline

Looking at the steps above, it looks simple to achieve, but while I was creating the pipeline, I´ve face some challenges to resolve to fully attend all aspects above.

This series are divided in 4 topics:

1. The code and Build Pipeline
2. The code analysis and unit tests steps
3. Building and publishing your Docker image
4. Final steps and summary

Part 1 – Code and Build Pipeline

Code

In this part I will show how to create a simple repository and a simple web api application in net core using swagger

I use Github as repository for this demo, but you can use AzureDevops Repo or even Bit Bucket as well.

Get the code repo here, you can use it in the following steps:

https://github.com/aledaccas/net-core-svc-devops-sample

The code consist in two projects, a web api application and a test project. The web api contains basic functionalities using the concepts of DI (Dependency Injection). The test project mocks the dependency and test it to produce the % of code coverage of your application.

Build Pipeline

To create your build pipeline, access your Azure Devops subscription (https://dev.azure.com/), create a project (in my case net-core-svc-devops-sample) and access the build pipelines list (https://dev.azure.com//net-core-svc-devops-sample/_build). Create a new pipeline by clicking the New pipeline button.

A new page will ask to select your code repository, you can use the Azure Repos Git, GitHub, Subversion, Bitbucket or another git version control. I will use the example GitHub repository (https://github.com/aledaccas/net-core-svc-devops-sample). Click Continue

In template page, select empty template and apply. The result will be a empty pipeline with one agent job. Change the pipeline agent pool to Hosted Ubuntu 1604. This will be necessary to build the docker image in linux version.

Press Ctrl+s to save your pipeline. Now you are ready to add the tasks to test, analyze and build your net core container image. Check next post for unit test and quality control.