---
title: "Azure DevOps"
metaTitle: "Azure DevOps Integration Guide | LoadFocus"
metaDescription: "Azure DevOps Integration Guide | LoadFocus — step-by-step LoadFocus documentation for cloud load testing, API monitoring, and performance insights."
order: 2
---

This guide explains how to integrate the LoadFocus JMeter API Client with Azure DevOps for automated performance testing.

## Setup Steps

### 1. Store Credentials in Azure Key Vault

For secure credential management, store your LoadFocus API credentials in Azure Key Vault:

1. Create a Key Vault in Azure if you don't have one
2. Add the following secrets:
   - `loadfocus-api-key`: Your LoadFocus API key
   - `loadfocus-team-id`: Your LoadFocus team ID
3. Set up a service connection to access the Key Vault from your pipeline

### 2. Create an Azure Pipeline

Create a new file named `azure-pipelines.yml` in your repository:

```yaml
trigger:
  - main
  - develop

pool:
  vmImage: 'ubuntu-latest'

variables:
  - group: loadfocus-variables  # Variable group containing Key Vault references

stages:
  - stage: Build
    jobs:
      - job: BuildAndTest
        steps:
          # Your existing build and test steps...

  - stage: PerformanceTest
    dependsOn: Build
    condition: succeeded()
    jobs:
      - job: RunPerformanceTests
        steps:
          - task: NodeTool@0
            inputs:
              versionSpec: '16.x'
            displayName: 'Install Node.js'

          - script: |
              npm install -g @loadfocus/loadfocus-api-client
            displayName: 'Install LoadFocus JMeter API Client'

          - script: |
              loadfocus-api config set apikey $(LOADFOCUS_API_KEY)
              loadfocus-api config set teamid $(LOADFOCUS_TEAM_ID)
            displayName: 'Configure LoadFocus API Client'

          - script: |
              loadfocus-api jmeter run-test \
                --name "AzureDevOps_$(Build.Repository.Name)_$(Build.SourceBranchName)" \
                --thresholds "avgresponse<=200,errors==0,p95<=250" \
                --format json > $(Build.ArtifactStagingDirectory)/performance_results.json
            displayName: 'Run Performance Tests'
            continueOnError: false

          - task: PublishBuildArtifacts@1
            inputs:
              pathtoPublish: '$(Build.ArtifactStagingDirectory)'
              artifactName: 'performance-test-results'
            displayName: 'Publish Performance Test Results'

  - stage: Deploy
    dependsOn: PerformanceTest
    condition: succeeded()
    jobs:
      - job: DeployApplication
        steps:
          # Your deployment steps...
```

### 3. Set Up Variable Group with Key Vault Integration

1. Go to Pipelines > Library > Variable Groups
2. Create a new Variable Group named "loadfocus-variables"
3. Link it to your Azure Key Vault
4. Add the following variables, linking them to your Key Vault secrets:
   - `LOADFOCUS_API_KEY`: Link to `loadfocus-api-key` secret
   - `LOADFOCUS_TEAM_ID`: Link to `loadfocus-team-id` secret

## Advanced Configuration

### Using YAML Templates

For reusable performance testing steps, create a template file `performance-test-template.yml`:

```yaml
parameters:
  testName: 'Default_Test'
  thresholds: 'avgresponse<=200,errors==0,p95<=250'
  waitTimeout: 1800

steps:
- script: |
    loadfocus-api jmeter run-test \
      --name "${{ parameters.testName }}" \
      --thresholds "${{ parameters.thresholds }}" \
      --waitTimeout ${{ parameters.waitTimeout }} \
      --format json > $(Build.ArtifactStagingDirectory)/performance_results.json
  displayName: 'Run Performance Tests'
  continueOnError: false
```

Then in your main pipeline:

```yaml
- template: performance-test-template.yml
  parameters:
    testName: 'AzureDevOps_$(Build.Repository.Name)_$(Build.SourceBranchName)'
    thresholds: 'avgresponse<=150,errors==0,p95<=200'
    waitTimeout: 2400
```

### Running Multiple Tests

To run multiple performance tests in sequence:

```yaml
- script: |
    # Run API test
    loadfocus-api jmeter run-test \
      --name "API_Test" \
      --thresholds "avgresponse<=200,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/api_test_results.json

    # Run UI test
    loadfocus-api jmeter run-test \
      --name "UI_Test" \
      --thresholds "avgresponse<=500,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/ui_test_results.json
  displayName: 'Run Multiple Performance Tests'
```

## Integration with Azure Test Plans

To integrate performance test results with Azure Test Plans:

```yaml
- task: PublishTestResults@2
  inputs:
    testResultsFormat: 'JUnit'
    testResultsFiles: '$(Build.ArtifactStagingDirectory)/test-results.xml'
    testRunTitle: 'Performance Tests'
  displayName: 'Publish Test Results'
  condition: succeededOrFailed()
```

You'll need to convert the JSON output to JUnit format:

```yaml
- script: |
    # Run performance test
    loadfocus-api jmeter run-test \
      --name "AzureDevOps_Test" \
      --thresholds "avgresponse<=200,errors==0" \
      --format json > $(Build.ArtifactStagingDirectory)/performance_results.json

    # Convert JSON to JUnit format (using a custom script)
    node convert-to-junit.js \
      $(Build.ArtifactStagingDirectory)/performance_results.json \
      $(Build.ArtifactStagingDirectory)/test-results.xml
  displayName: 'Run Performance Tests and Convert Results'
```

## Tips for Azure DevOps Integration

1. **Parallel Jobs**: If you have multiple performance tests, consider using parallel jobs:

   ```yaml
   jobs:
   - job: API_Performance_Test
     steps:
       # Run API performance test

   - job: UI_Performance_Test
     steps:
       # Run UI performance test
   ```

2. **Deployment Gates**: Use performance test results as a deployment gate:

   ```yaml
   - job: DeploymentGate
     steps:
     - script: |
         # Check if performance tests passed
         if grep -q '"overallResult": "FAILED"' $(Build.ArtifactStagingDirectory)/performance_results.json; then
           echo "##vso[task.logissue type=error]Performance tests failed"
           echo "##vso[task.complete result=Failed;]"
         fi
     ```

3. **Custom Dashboard**: Create a custom dashboard to visualize performance test results over time.

4. **Notifications**: Set up notifications for performance test failures:

   ```yaml
   - task: SendEmail@1
     inputs:
       to: 'team@example.com'
       subject: 'Performance Test Failed'
       body: 'Performance tests failed to meet thresholds. See attached results.'
       addAttachment: true
       attachmentPath: '$(Build.ArtifactStagingDirectory)/performance_results.json'
     condition: failed()
   ```

For more information, refer to the [Azure DevOps documentation](https://docs.microsoft.com/en-us/azure/devops/) and the [LoadFocus API Client documentation](https://bitbucket.com/loadfocus/loadfocus-api-client).