Bulk Test APIs Before Production — Azure DevOps Release Gate With Azure Durable Functions | by Marcus Tee | Apr, 2022

Photograph by Mikhail Fesenko on Unsplash

Launch pipeline in Azure DevOps permits builders to deploy purposes throughout a number of phases. The discharge pipeline is analogous in the best way that DevOps engineers can outline automated duties and jobs akin to construct course of, unit take a look at, integration take a look at, and so on.

Along with the duties, we are able to additionally outline pre-deployment situation test and post-deployment situation test, earlier than the package deal progresses to subsequent phases. The diagram under illustrates the stream visually.

Supply: https://docs.microsoft.com/en-us/azure/devops/pipelines/release/approvals/?view=azure-devops

Below the circumstances, we are able to both outline human intervention, which requires approval from chosen members, or outline gates, which have a number of automation duties that we are able to carry out to test the situation earlier than releasing the deployment.

This text will deal with Launch Gates. The discharge gate can guarantee a further layer of inspection, whether or not it’s checking in opposition to compliance, or validation on utility performance or readiness, which might help to scale back points after our deployment.


As a part of the automated testing stage, builders will usually embrace automated unit testing and integration testing inside the pipeline. When it comes to useful testing, there’s a mix of each automated methods and getting testers to carry out the testing. A reasonably frequent useful testing is performing REST API calls, to make sure the providers are working as meant.

In addition to calling APIs for the methods, it will probably additionally contain calling exterior APIs, for instance, checking the standing of exterior endpoints, compliance checking, and so on.

There are a number of choices obtainable below the discharge gate, as proven within the diagram under.

Checking Azure Coverage compliance is usually used, as that permits clients to deploy workload in an surroundings that complies with group requirements. We will additionally invoke APIs by way of generic connection, or Azure Capabilities. Lastly, querying Azure Monitor alerts and work objects us vital too to make sure the discharge to the brand new surroundings follows sure requirements. You may get extra particulars relating to the discharge gate right here: https://docs.microsoft.com/en-us/azure/devops/pipelines/release/approvals/gates?view=azure-devops

Defining a generic connection for REST API is easy. We will simply create a service connection on the venture setting and outline the server URL and authentication particulars.

This works for a number of APIs. We will outline them one after the other. How about 20, 30, or extra APIs?

Chances are you’ll be questioning why don’t we do it inside the pipeline then. Sure, we are able to embrace this exercise inside the pipeline. A serious distinction right here is the power to find out whether or not the deployment can proceed to the following stage or surroundings, by defining the situation of the outcomes, coupled with handbook intervention on human approval.

Again to service connection. As proven within the diagram, successfully we have to outline the endpoints one after the other, which isn’t possible if we’re calling greater than 10 endpoints. The query will then be, is there a approach to orchestrate all of the API calls and mixture the responses, to function a launch gate?


Azure Capabilities is nicely generally known as serverless compute for “Capabilities-As-A-Service”, usually utilized in microservices workload. It’s normally stateless and short-lived. Azure Sturdy Capabilities, alternatively, is supposed to deal with the stateful job, along with the advantages of Azure Capabilities. Most notably, Azure Sturdy Capabilities excels in serving as an orchestrator to carry out duties in parallel, or in outlined sequences. There are numerous utility patterns for Azure Sturdy Capabilities for various use instances, documented right here: https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview?tabs=csharp

On this context, we are able to use Fan out/fan in sample for this use case. The concept is easy. We invoke an orchestrator, which is able to then invoke the checklist of REST APIs, and eventually mixture the outcomes and return as output.

Let’s see how this works intimately.

Azure Sturdy Capabilities Orchestrator

I’ll begin with the template. Utilizing VS Code or Visible Studio, I can choose Azure Capabilities Template, and on this case, I chosen Sturdy Capabilities Orchestration as the start line. The next template is generated.

It would generate 3 capabilities, specifically “DurableFunctionsOrchestration”, “DurableFunctionsOrchestration_Hello”, and “DurableFunctionsOrchestration_HttpStart”. Let’s perceive them from the underside.

DurableFunctionsOrchestration_HttpStart” is outlined because the entry level for the workflow, serving as a sturdy consumer. As proven on line 27, it’s utilizing HTTP Set off. What it means is that it’ll settle for HTTP GET or HTTP Put up, and begin the orchestration stream. In fact, relying on the use case, we outline different triggers too, akin to timer set off, Azure Service Bus set off, and so on. Right here’s the checklist of bindings obtainable, and you should utilize the supported binding for the set off.

On this instance, I’ll keep on with HTTP set off. It’s straightforward to invoke, and this HTTP set off will return the orchestration particulars as HTTP response, akin to orchestration standing, output, and so on, which is required on this case.

Let’s transfer to “DurableFunctionsOrchestration”. Because the title suggests, this perform orchestrates the actions. I can outline how the actions are being orchestrated, akin to working in asynchronisation mode or working in serial relying on the output of the earlier exercise. Within the instance above, from strains 10 to 12, it merely triggers the exercise in serial, which is doing a perform chaining. That is the place the place we design one of many six patterns talked about above.

The focused exercise from “DurableFunctionsOrchestration” is known as “DurableFunctionsOrchestration_Hello”, taking a string as enter. That is the place all of the heavy-lifting is carried out.

Again to our situation. The concept is to create a perform, which goals to problem a number of API calls to validate the standing and output and return the outcomes again to Azure Pipeline launch gate.

Now that we get the concept of Azure Sturdy Capabilities, let’s see how we are able to implement it on this situation. I’ll begin with the exercise, the capabilities that carry out all of the heavy lifting duties.

I named it HealthCheck_Executor. For demo functions, I merely do an echo to my backend API, validated that the returned message is identical as my enter. The one further motion I did is to assemble an object known as APICheckObject, to seize API title and its standing. Bear in mind, I wish to mixture all outcomes, in a while, therefore doing a 1 or 0 is a straightforward means, and on the similar time, I can determine which API isn’t functioning as meant.

Subsequent, let’s transfer on to the orchestrator. The primary query to handle is, what’s the proper sample ought to I exploit? Perform chaining and Fan out/fan in appears to be a viable candidate.

I’ll go for perform chaining, if the APIs are examined in sequence, for instance, the second API will depend on the output of the primary API. In my case, all of the APIs are impartial of one another, therefore I go for Fan-out/fan in, to parallelize all execution for a shorter execution time.

I’ll then return the consequence as an inventory of objects because the output of your complete course of.

The final piece of the puzzle is a approach to invoke this sturdy perform. I’ll stick to HTTP set off, however I would like another factor. If I name this sturdy perform instantly, it’ll return a number of URLs, primarily for us to test the standing or terminate the duty. Azure Pipeline launch gate will be unable to devour the output.

To deal with this, I can merely create one other Azure Capabilities utilizing HTTP set off, to invoke this sturdy perform, and on the similar time, mixture the output for validation in Azure DevOps.

The total supply code will be discovered on GitHub.

Azure Pipeline Launch Gate Validation

Let’s examine the output from the Azure Capabilities above. I’ve the whole success name, in addition to the respective API title and its standing.


In Azure Pipeline, let’s transfer to the discharge pipeline and modify our launch gate. So as to add the Azure Capabilities within the launch gate, we are able to both go for pre-deployment or post-deployment. In my case, I’ll go for post-deployment. Including Azure Capabilities is easy. Merely click on “+ Add” on the highest left nook below “Gates”, and put within the Azure Capabilities URL and Azure Capabilities Key. If you happen to don’t know the place to retrieve the important thing, it’s inside Azure Portal.

I confirmed the API response simply now, and now I can outline the success standards for this post-deployment test. I’ll test in opposition to the whole variety of profitable calls, and the test is handed, if the success name is inside my parameter. You may get extra particulars on different methods of defining the situation within the documentation.

Right here’s what my launch gate appears like.

To validate it, merely create a launch and test the logs. You’ll discover that the situation is checked twice, in 5 minutes intervals. You’ll be able to outline the parameter contained in the deployment gate web page above.

The diagram under visualizes your complete stream.

With that, now you possibly can validate the API in batch and solely launch the appliance to the manufacturing surroundings after validation routinely!

More Posts