Azure DevOps

1. Azure DevOps Overview and DevOps Lifecycle

DevOps Lifecycle Phases:

• Plan: Track work with Azure Boards including Kanban boards, backlogs, sprint planning.

• Develop: Manage source code with Azure Repos (Git or TFVC).

• Build: Automate builds and run tests with Azure Pipelines (CI).

• Release: Deploy applications automatically through multi-stage release pipelines (CD).

• Operate: Monitor and manage deployed apps (integrations available).

• Feedback: Collect user feedback to improve apps and processes.

2. Core Services of Azure DevOps

3. DevOps Pipeline Types: YAML vs Classic Pipelines

YAML Pipelines (Pipeline as Code)

• Define pipeline configuration as code in a YAML file stored alongside your codebase.

• Supports versioning and branching with the source code.

• Enables multi-stage pipelines (build + deploy) in a single file.

• Easily extensible, reusable templates, and parameterized inputs.

• Preferred for infrastructure as code, automation, modern DevOps processes.

trigger:
- main

stages:
- stage: Build
  jobs:
  - job: BuildJob
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: DotNetCoreCLI@2
      inputs:
        command: 'build'
        projects: '**/*.csproj'

- stage: Deploy
  dependsOn: Build
  jobs:
  - deployment: DeployWeb
    environment: 'Production'
    pool:
      vmImage: 'ubuntu-latest'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              azureSubscription: 'MyAzureSubscription'
              appName: 'mywebapp'
              package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

Classic Pipelines (UI Editor)

• Visual drag-and-drop editor.

• Separate build and release pipelines.

• Easier for beginners or quick pipelines.

• Less portable or version controlled compared to YAML.

4. Continuous Integration (CI) and Continuous Deployment (CD)

• Continuous Integration (CI): Automate building and testing of code on changes pushed to repositories. Ensures code quality by running unit, integration tests, and produces build artifacts.

• Continuous Deployment (CD): Automate delivery of tested artifacts to target environments (Dev, QA, Prod) using release pipelines or multi-stage YAML pipelines. Supports approvals, gates, and environment strategies (canary, blue/green).

5. Infrastructure as Code (IaC)

• Azure Resource Manager (ARM) templates

• Terraform

• Ansible, Chef, Puppet (via pipelines)

• Bicep

6. Integrations: External Resources, Service Connections, Secrets Management

• Service Connections: Define and manage connections to external services and clouds (Azure, AWS, GitHub, Docker Hub, Kubernetes clusters), enabling pipelines to authenticate securely.

• Secrets Management: Use Azure Key Vault linked in pipelines to retrieve secrets securely at runtime.

• Variable Groups: Manage shared variables and secrets with tight access controls.

• Supports OAuth, PATs (Personal Access Tokens), and managed identities.

7. Building a Multi-stage YAML Pipeline: Example and Explanation

trigger:
- main

variables:
  buildConfiguration: 'Release'

stages:
- stage: Build
  displayName: 'Build Stage'
  jobs:
  - job: Build
    pool:
      vmImage: ubuntu-latest
    steps:
    - script: dotnet build --configuration $(buildConfiguration)
      displayName: 'Build solution'

- stage: Test
  displayName: 'Test Stage'
  dependsOn: Build
  jobs:
  - job: Test
    pool:
      vmImage: ubuntu-latest
    steps:
    - script: dotnet test --configuration $(buildConfiguration) --no-build
      displayName: 'Run tests'

- stage: Deploy
  displayName: 'Deploy Stage'
  dependsOn: Test
  condition: succeeded()
  jobs:
  - deployment: DeployWeb
    environment: 'production'
    pool:
      vmImage: ubuntu-latest
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to production"

8. Difference Between Azure Repos and GitHub Integration in Azure Pipelines

9. Managing Secrets in Azure DevOps Pipelines

• Use Azure Key Vault integration: Link Azure Key Vault as a service connection and fetch secrets as pipeline variables at runtime.

• Use Pipeline Variable Groups with secrets marked as secret; encrypted and masked in logs.

• Store secrets as pipeline variables and mark them secret (not visible in logs).

• Avoid storing sensitive data in source code or plain variables.

• Use Managed Identities for Azure resources to authenticate without secrets.

10. Summary: Azure DevOps Key Concepts

FAQ

• Azure Repos: Source code management using Git or Team Foundation Version Control (TFVC).

• Azure Pipelines: Build, test, and deploy automation via pipelines using YAML or classic editors.

• Azure Boards: Work item tracking, agile planning, sprint management.

• Azure Artifacts: Package hosting/managing for npm, NuGet, Maven, etc.

• Azure Test Plans: Manual and exploratory testing.

• YAML Pipelines: Pipeline as code, stored with the source code, easily versioned and reviewed. Supports multi-stage pipelines in one file, best suited for automation and infrastructure-as-code.

• Classic Pipelines: Visual editor drag-and-drop UI, separate build and release pipelines. More user-friendly for beginners but less flexible and harder to version control.

trigger:
- main

stages:
- stage: Build
  jobs:
  - job: BuildJob
    pool:
      vmImage: ubuntu-latest
    steps:
    - script: dotnet build --configuration Release

- stage: Test
  dependsOn: Build
  jobs:
  - job: TestJob
    pool:
      vmImage: ubuntu-latest
    steps:
    - script: dotnet test --no-build

- stage: Deploy
  dependsOn: Test
  jobs:
  - deployment: DeployJob
    environment: 'Production'
    pool:
      vmImage: ubuntu-latest
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to production"

• Use Azure Key Vault integration by linking Key Vault as a service connection and fetching secrets securely at pipeline runtime.

• Define Variable Groups with secret variables marked encrypted and masked in logs.

• Use pipeline variables set as secret to avoid exposing sensitive info in logs.

• Never store secrets in source code or plain text variables.

Intermediate and Scenario-Oriented Questions

• Azure Repos: Native Git repositories hosted inside Azure DevOps, with tight integration with Boards, Pipelines, and Azure AD-based access control.

• GitHub Integration: External GitHub repositories can trigger Azure Pipelines, requiring OAuth apps or PATs for authentication. GitHub manages PR and branch policies. Both can trigger pipelines, but Azure Repos offers deeper integration within the Azure DevOps ecosystem.

Advanced & Tricky Interview Questions

• Use caching for dependencies/tools to avoid repeated downloads.

• Parallelize jobs and steps where possible.

• Limit scope of triggered builds (CI triggers for specific paths).

• Use self-hosted agents for faster build speeds or customized environments.

• Avoid unnecessary tasks or stages.

• Using deployment slots (e.g., in App Service) for quick swap back.

• Automating rollback steps in the pipeline with rollback scripts or infrastructure redeployment.

• Keeping previous working build artifacts for redeployment.

• Using approvals and manual interventions to halt faulty deployments early.

• Check pipeline logs for error messages and failed steps.

• Verify service connections and permissions.

• Check for changed dependencies or upstream build artifacts.

• Confirm agent availability and health.

• Validate pipeline YAML syntax and variables.

• Test pipeline steps separately in local or simplified runs.

• Look at environment or quota limitations.