devops on azure is all about bringing development and it operations together. it helps us deliver software faster, with better quality and more reliability. azure gives us a strong platform to set up devops. it has tools for continuous integration (ci), continuous delivery (cd), infrastructure as code (iac), and monitoring.

with azure devops, we can manage code repositories, automate workflows, and deploy apps easily to services like azure app service or kubernetes. it has different services like azure repos, pipelines, boards, artifacts, and test plans. these services help at every step of the devops lifecycle. they make collaboration easy and create a smooth delivery process.

why choose azure for devops?

azure gives us a complete devops solution. it comes with enterprise-level tools, great scalability, and availability worldwide. it supports many programming languages, frameworks, and third-party tools. this makes it flexible for different types of projects.

azure devops is known for its strong ci/cd pipelines. it works well with github and makes deploying apps to azure cloud simple. security is a big focus. tools like azure key vault help us manage secrets, and azure policy takes care of governance.

azure also uses ai to give us insights and monitoring tools like application insights. these help fix issues before they become big problems and improve performance. all of this makes azure a great platform for modern devops practices.

setting up azure devops

azure devops gives us tools to handle the whole software process, from planning to deployment. setting it up is simple. we prepare the environment, create an organization, and use services like azure repos and pipelines. let's go step by step.

prerequisites

before you start, make sure you have these ready −

azure account − you can create one on the azure portal.
subscription − an active azure subscription is needed for advanced features.
git installed − check if git is installed. use git --version to confirm.
development environment − use tools like visual studio or vs code. they work directly with azure devops.

creating an azure devops organization

an organization in azure devops is like a main container for projects and users.

sign in − go to azure devops and log in with your microsoft account.

create organization

click new organization.
enter a name, like mydevopsorg, and choose a region.
click continue.
add a project:
inside your organization, click new project.
add details like the project name, visibility (private or public), and version control (git or tfvc).

given below is an example yaml for setting up a pipeline −

trigger:
  - main
pool:
  vmimage: 'ubuntu-latest'
steps:
  - script: echo "hello azure devops!"
    displayname: 'print message'

overview of azure devops services

azure devops offers several services. we can pick and use only the ones we need −

azure repos − helps us manage code repositories. example to push code −

git init  
git remote add origin https://dev.azure.com/mydevopsorg/myproject/_git/myrepo  
git add .  
git commit -m "initial commit"  
git push -u origin main

azure pipelines − automates ci/cd workflows. for example, deploying a node.js

app:
pool:
  vmimage: 'ubuntu-latest'
steps:
  - task: nodetool@0
    inputs:
      versionspec: '14.x'
  - script: npm install
    displayname: 'install dependencies'
  - script: npm test
    displayname: 'run tests'

azure boards − tracks tasks, sprints, and overall progress.

azure test plans − lets us manage and automate tests.

azure artifacts − handles and shares packages like npm, maven, or nuget.

this setup makes it easy to fit azure devops into existing workflows. it's efficient and scales well for different needs.

azure pipelines: ci / cd

azure pipelines helps us automate building, testing, and deploying apps. it has two options - yaml pipelines for more flexibility and classic pipelines with a simple graphical interface. heres how we can create and use these pipelines for continuous integration (ci) and continuous deployment (cd).

creating build pipelines

build pipelines help us compile source code, run tests, and create build artifacts.

steps to create

open pipelines in your azure devops project.
click new pipeline.
choose the repository you want (like github or azure repos).
pick a yaml file or set up with a template.

example yaml build pipeline for a .net project −

trigger:
  - main
pool:
  vmimage: 'windows-latest'
steps:
  - task: usedotnet@2
    inputs:
      packagetype: 'sdk'
      version: '6.x'
  - script: dotnet build
    displayname: 'build the project'
  - script: dotnet test
    displayname: 'run unit tests'

save this file as azure-pipelines.yml in the main folder of your repo.

every time we push to the main branch, this pipeline will run.

setting up release pipelines

release pipelines let us deploy build artifacts to environments like staging or production.

steps to create −

go to pipelines > releases.
click new pipeline and choose a template (like azure app service deployment).
link it to the build artifacts from the build pipeline.
add stages for deployment (e.g., development, testing, production).

example configuration for web app deployment −

artifact source − link to the output from the build pipeline.
tasks − add azure app service deploy task. fill in app service name, package or folder, and azure subscription.

yaml pipelines vs classic pipelines

the following table highlights how yaml pipelines differ from classic pipelines −

feature	yaml pipelines	classic pipelines
definition	stored in a yaml file in the repo.	configured through azure devops ui.
flexibility	very customizable and version-controlled.	simple setup for smaller projects.
triggering	works with branches, pull requests, etc.	fewer triggering options.
example yaml	below example shows deployment to azure app service:	not applicable

trigger:
  - main
pool:
  vmimage: 'ubuntu-latest'
steps:
  - task: azurewebapp@1
    inputs:
      azuresubscription: '<your azure subscription>'
      appname: '<your app service name>'
      package: '$(pipeline.workspace)/drop/*.zip'

yaml pipelines work best for big projects and teams. they allow automation and collaboration. classic pipelines are simpler and good for quick setups or if yaml seems too complex.

infrastructure as code (iac) with azure

infrastructure as code (iac) helps us manage cloud resources with code. it makes provisioning automatic and simpler. azure supports many iac tools. these tools bring consistency, version control, and easy repeatability. we can use azure resource manager (arm) templates, terraform, or similar tools to define and deploy infrastructure easily.

introduction to iac on azure

azure supports iac with −

arm templates − these are json-based templates made just for azure.
terraform − a third-party tool that works across different clouds, including azure.

using iac reduces mistakes because it removes most manual steps. it keeps environments consistent and makes rolling back changes easier. when we use iac with ci/cd pipelines, it ensures smooth and automated setups for infrastructure.

using azure resource manager (arm) templates

arm templates define azure resources in json. they work declaratively, so we write what we need, and azure sets it up.

structure

resources − list the azure services to deploy.
parameters − these make the templates reusable. we can provide inputs like names or regions.
outputs − they return key information after deployment.

example arm template for a virtual machine

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymenttemplate.json#",
  "contentversion": "1.0.0.0",
  "parameters": {
    "vmname": { "type": "string" },
    "adminusername": { "type": "string" },
    "adminpassword": { "type": "securestring" }
  },
  "resources": [
    {
      "type": "microsoft.compute/virtualmachines",
      "apiversion": "2021-07-01",
      "name": "[parameters('vmname')]",
      "location": "eastus",
      "properties": {
        "hardwareprofile": { "vmsize": "standard_ds1_v2" },
        "osprofile": {
          "computername": "[parameters('vmname')]",
          "adminusername": "[parameters('adminusername')]",
          "adminpassword": "[parameters('adminpassword')]"
        }
      }
    }
  ]
}

deployment − deploy with azure cli.

managing iac with terraform and azure

terraform is another tool we can use to manage azure resources. it's flexible, supports multiple clouds, and tracks the state of resources.

install terraform − download terraform from terraform downloads.

create terraform configuration

provider "azurerm" {
   features {}
}
resource "azurerm_resource_group" "example" {
   name     = "example-resources"
   location = "eastus"
}
resource "azurerm_storage_account" "example" {
   name                     = "examplestorageacct"
   resource_group_name      = azurerm_resource_group.example.name
   location                 = azurerm_resource_group.example.location
   account_tier             = "standard"
   account_replication_type = "lrs"
}

use the following commands to manage resources −

initialize

terraform init

plan

terraform plan

apply

terraform apply

terraform lets us reuse configurations, manage the state, and use many community modules. these make managing azure resources easier and faster.

monitoring and logging with azure

azure gives us strong tools to track how resources perform, how applications run, and to spot any problems. below is a simple overview in a table format.

feature	description	example
integrating azure monitor	helps monitor azure resources and apps from one place.	set up alert for high cpu usage: az monitor metrics alert create --name highcpualert.
application insights for observability	tracks how apps perform and how users interact with them.	add this code to track events: appinsights.trackevent({ name: "userlogin" });.
log analytics for devops	lets us query and analyze log data using kql (kusto query language).	example query: `azurediagnostics`

security in azure devops

azure devops offers built-in security features to protect our resources, manage secret data, and keep pipelines safe. below is a quick summary.

feature	description	example
managing permissions and access control	uses rbac (role-based access control) to protect resources.	add permission: az devops security permission add --id <role-id> --user-id <user-id>.
secrets management with azure key vault	stores secrets, keys, and certificates safely.	pipeline task example: use azurekeyvault@2 to get secrets for deployment.
integrating security testing in pipelines	adds automatic security checks in ci/cd pipelines for both static and dynamic testing.	add tasks like whitesource bolt or sonarqube in yaml to find vulnerabilities during builds.

yaml example for secure deployment with key vault integration −

trigger:
  - main
pool:
  vmimage: 'ubuntu-latest'
steps:
  - task: azurekeyvault@2
    inputs:
      azuresubscription: 'myazuresubscription'
      keyvaultname: 'mykeyvault'
      secretsfilter: '*'
  - script: echo $(mysecret)
    displayname: 'display secret for debugging'

conclusion

in this chapter, we focused on setting up azure devops, creating ci/cd pipelines, using infrastructure as code (iac) with arm templates and terraform, and making sure our monitoring, logging, and security practices are strong.

by using azure monitor, application insights, and log analytics, we made resource management and observability better. we also talked about how to secure azure devops by controlling access, managing secrets with azure key vault, and adding security tests to pipelines. these practices help automate, secure, and monitor the software delivery process, making devops workflows on azure more efficient, reliable, and safe.

Save or share this article