Study guide

5.5 Pipeline Artifact Versioning & Artifact Storage Strategy

Microsoft Certified: Azure DevOps Engineer Expert AZ-400

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Flow of Work, Traceability & Work Tracking

1.1 Flow of Work, GitHub Flow & Feedback Cycles 1.2 Work Tracking with Azure Boards & GitHub Projects 1.3 End-to-End DevOps Traceability & Quality Tracking

2 Chapter 2: DevOps Metrics, Dashboards & Team Collaboration

2.1 DORA Metrics, Flow Metrics & Dashboard Design 2.2 Lifecycle Metrics Across the Six DevOps Phases 2.3 Work Item Queries, WIQL Charts & Analytics 2.4 Project Documentation: Wikis, Mermaid Diagrams & Release Notes 2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps

3 Chapter 3: Git Branching Strategies & Pull Request Workflows

3.1 Git Branching Models & Strategy Design 3.2 Pull Request Workflows & Merge Strategies 3.3 Branch Policies, Quality Gates & Compliance Restrictions

4 Chapter 4: Repository Management, Optimization & Git Data Operations

4.1 Git LFS Architecture & .gitattributes Tracking 4.2 LFS History Migration, git-fat & File Locking 4.3 Git Repository Scaling, Scalar & Monorepo Governance 4.4 Repository Permissions & Git Tag Governance 4.5 Git Data Recovery & Sensitive-Data Scrubbing

5 Chapter 5: Package Management & Dependency Versioning

5.1 Selecting Package Tools: Azure Artifacts vs. GitHub Packages 5.2 Feed Scoping, Upstream Sources & Pipeline Authentication 5.3 Package Views, Immutability & Quality Promotion 5.4 Dependency Versioning: SemVer, CalVer & Automated Versioning 5.5 Pipeline Artifact Versioning & Artifact Storage Strategy

6 Chapter 6: Pipeline Infrastructure, Agents & Integration

6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions 6.2 GitHub-Azure Pipelines Integration & Hybrid Migration 6.3 Hosted vs. Self-Hosted Agents & Runners 6.4 VMSS Elastic Pools, Container Jobs & Agent Governance 6.5 Pipeline Triggers, Filters & Concurrency Management

7 Chapter 7: YAML Pipeline Architecture & Reusable Elements

7.1 YAML Pipeline Anatomy: Stages, Jobs, Steps & Workspaces 7.2 Job Execution Order: DAG Dependencies, Parallelism & Conditions 7.3 Reusable Elements: Templates, Parameters & Variables 7.4 Variable Groups, Secret Variables & Key Vault Linking 7.5 YAML Environments, Checks & Deployment Approvals

8 Chapter 8: Testing Strategy, Quality Gates & Code Coverage

8.1 Test Strategy Design: Local, Unit & Integration Testing 8.2 Load, Stress & Performance Testing in Pipelines 8.3 Test Execution Tasks, Agents & Results Integration 8.4 Code Coverage Analysis & SonarQube Integration 8.5 Quality Gates, Release Gates & Governance Checks

9 Chapter 9: Modern Deployment Strategies & Zero-Downtime Delivery

9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments 9.2 Minimizing Downtime: Deployment Slots & Rolling Updates 9.3 Feature Flags with Azure App Configuration & Feature Manager 9.4 Designing the High-Priority Hotfix Path 9.5 Ordered Dependency Deployments, Resiliency & Rollback

10 Chapter 10: Artifact Deployment & Database DevOps

10.1 Containerized Application Delivery: ACR, AKS & Container Apps 10.2 Binary, Web App, Function & Scripted Deployments 10.3 Database DevOps: State-Based & Migration-Based Strategies

11 Chapter 11: Infrastructure as Code (IaC) & Azure Deployment Environments

11.1 Infrastructure as Code Strategy: Bicep, ARM & Terraform 11.2 Desired State Configuration & Azure Machine Configuration 11.3 Azure Deployment Environments (ADE) & Developer Self-Service

12 Chapter 12: Pipeline Maintenance, Health & Modernization

12.1 Pipeline Health, Flaky Tests & Reliability Engineering 12.2 Pipeline Optimization: Caching, Slicing & Concurrency 12.3 Artifact & Build Retention Governance 12.4 Modernizing CI/CD: Classic to YAML Migration

13 Chapter 13: Authentication, Authorization & Identity Governance

13.1 Microsoft Entra Service Principals & Managed Identities 13.2 Service Connections, Workload Identity & Personal Access Tokens 13.3 Azure DevOps Projects, Teams & Permission Evaluation 13.4 Access Levels, GitHub Roles & Outside Collaborators

14 Chapter 14: Secrets Management, Sensitive Data & DevSecOps Scanning

14.1 Azure Key Vault, Secret Variables & Secretless CI/CD 14.2 Security Scanning Strategy, GHAS & Secret Scanning 14.3 CodeQL SAST in Pipelines and Containers 14.4 Software Supply Chain, Container Scanning & Cloud Defender

15 Chapter 15: Telemetry Collection, Azure Monitor & Alerting

15.1 Azure Monitor Architecture, AMA & Data Collection Rules 15.2 Application Insights & Specialized Azure Monitor Insights 15.3 Alerting Rules, Action Groups & GitHub Repository Insights

16 Chapter 16: Telemetry Analysis, Distributed Tracing & SRE Practices

16.1 Distributed Tracing, Application Map & Exception Triage 16.2 KQL Log Analytics, SRE Observability & Error Budgets

5.5 Pipeline Artifact Versioning & Artifact Storage Strategy

Key Takeaways Explain This Topic AI

PublishPipelineArtifact and DownloadPipelineArtifact use content-addressable deduplication and parallel transfer, and are substantially faster than the legacy build artifact tasks.

Build artifacts (PublishBuildArtifacts) are the legacy mechanism retained for compatibility and for on-premises file share drops.

Naming artifacts with the resolved build version, for example drop-$(GitVersion.SemVer), is what makes a downstream stage able to prove which build it deployed.

Artifacts are scoped to a pipeline run and expire with the run's retention policy; anything that must outlive the run belongs in a feed as a package.

Universal Packages are the answer for artifacts above the 500 MiB package ceiling or for payloads that must be consumed by pipelines in other projects.

Last updated: September 2026

5.5 Pipeline Artifact Versioning & Artifact Storage Strategy

A version number is only useful if the artifact carrying it can move reliably between stages. Azure Pipelines offers three transport mechanisms with very different performance and lifetime characteristics, and the choice between them is a size and retention decision.

Pipeline Artifacts vs. Build Artifacts in Azure Pipelines

In multi-stage Azure Pipelines, each stage frequently executes on a clean, ephemeral virtual machine. To pass compiled binaries, test coverage results, or deployment scripts from a Build stage to subsequent Staging and Production deployment stages, intermediate artifacts must be preserved.

Azure Pipelines provides two distinct mechanisms for artifact transport: Pipeline Artifacts (modern) and Build Artifacts (legacy). Artifact Transport Architecture in Azure Pipelines:

  • [Stage 1: Build & Compile]
  • │
  • ├── Compiles 10,000 files (1.2 GB)
  • ▼
  • [Task: PublishPipelineArtifact@1]
  • │
  • ├── Chunking Engine: Slices files into content-addressable blocks
  • ├── Deduplication: Uploads only unique blocks; skips duplicates
  • ├── Multi-threaded parallel transfer over HTTPS
  • ▼
  • [Azure Artifacts Dedicated Storage Backend]
  • │
  • ├── Ephemeral storage linked strictly to Pipeline Run lifecycle
  • │
  • ▼
  • [Task: DownloadPipelineArtifact@2]
  • │
  • ├── Parallel multi-stream download directly to Deployment Agent
  • ▼
  • [Stage 2: Staging Deployment Job]
  • Deep Architectural Comparison

Legacy Build Artifacts ( PublishBuildArtifacts@1 / DownloadBuildArtifacts@0 ):

Uploads files as a standard flat file stream or .zip archive to Azure DevOps server storage or an on-premises Windows UNC network file share ( \\server\share ).

Uploads files sequentially or in basic batches without chunk-level deduplication.

Performance Problem: For large builds containing thousands of small files (such as compiled web apps, unpacked symbols, or node_modules ), the per-file overhead causes upload and download times to degrade dramatically.

Modern Pipeline Artifacts ( PublishPipelineArtifact@1 / DownloadPipelineArtifact@2 ):

Built on dedicated Azure Artifacts cloud storage infrastructure.

Content-Addressable Chunking & Deduplication: Files are sliced into content-addressed chunks. If multiple files share identical chunks, or if unchanged chunks were previously uploaded, they are not re-uploaded.

Massive Performance Gain: Operates up to 10x faster than legacy Build Artifacts, particularly when transferring repositories with high file counts.

Cross-Stage & Cross-Pipeline Sharing: Pipeline artifacts can be downloaded across stages in the same pipeline or shared across completely separate build and release pipelines.

Pipeline Artifacts vs. Build Artifacts vs. Universal Packages

  • Feature Pipeline Artifacts Legacy Build Artifacts Universal Packages
  • Publish Task PublishPipelineArtifact@1 PublishBuildArtifacts@1 UniversalPackages@0
  • Download Task DownloadPipelineArtifact@2 DownloadBuildArtifacts@0 UniversalPackages@0
  • Underlying Engine Deduplicated chunk storage Flat server file store / UNC Package feed storage
  • Transfer Speed Ultra-Fast (Parallel & Deduplicated) Slow on high file counts Optimized for massive blobs
  • Storage Retention Linked to Pipeline Run retention Linked to Pipeline Run retention Permanent feed retention
  • Immutability Ephemeral build outputs Ephemeral build outputs Permanent immutable versions
  • AZ-400 Status Current Gold Standard for CI/CD Legacy (Deprecated pattern) Standard for arbitrary 4 TiB tools
  • Production-Grade Multi-Stage YAML Pipeline Passing Deduplicated Artifacts

The following YAML pipeline demonstrates using GitVersion for automated SemVer calculation, publishing compiled binaries via PublishPipelineArtifact@1 , and downloading them in an isolated deployment stage via DownloadPipelineArtifact@2 : # azure-pipelines-artifacts.yml

trigger:

branches:

include:

- main

pool:

vmImage: 'ubuntu-latest'

stages:

  • # =========================================================================
  • # STAGE 1: Build, Test & Package with Automated Versioning
  • # =========================================================================
  • stage: BuildStage
  • displayName: 'Build & Test'

jobs:

- job: CompileJob

steps:

  • checkout: self
  • fetchDepth: 0 # Required for GitVersion to calculate history
  • # 1. Execute GitVersion to calculate SemVer dynamically
  • task: gitversion/setup@0
  • displayName: 'Install GitVersion Tool'

inputs:

versionSpec: '5.x'

  • task: gitversion/execute@0
  • displayName: 'Derive Semantic Version'

inputs:

  • useConfigFile: true
  • configFilePath: 'GitVersion.yml'
  • script: |
  • echo "Derived SemVer: $(GitVersion.SemVer)"
  • echo "Derived FullSemVer: $(GitVersion.FullSemVer)"
  • echo "Derived AssemblySemVer: $(GitVersion.AssemblySemVer)"
  • displayName: 'Log GitVersion Metadata'
  • # 2. Compile application embedding derived version
  • task: DotNetCoreCLI@2
  • displayName: 'Publish ASP.NET Core Binaries'

inputs:

  • command: 'publish'
  • publishWebProjects: true

arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)/app -p:Version=$(GitVersion.SemVer)'

zipAfterPublish: false

  • # 3. Publish Pipeline Artifact using modern deduplicated task
  • task: PublishPipelineArtifact@1
  • displayName: 'Publish WebApp Pipeline Artifact'

inputs:

  • targetPath: '$(Build.ArtifactStagingDirectory)/app'
  • artifactName: 'drop-webapp'
  • publishLocation: 'pipeline'
  • # =========================================================================
  • # STAGE 2: Deploy to Staging Environment
  • # =========================================================================
  • stage: DeployStaging
  • displayName: 'Deploy to Staging'
  • dependsOn: BuildStage
  • condition: succeeded()

jobs:

  • deployment: DeployJob
  • environment: 'Staging'

strategy:

runOnce:

deploy:

steps:

  • # 4. Download Pipeline Artifact into fresh deployment agent
  • task: DownloadPipelineArtifact@2
  • displayName: 'Download WebApp Artifact'

inputs:

  • buildType: 'current'
  • artifactName: 'drop-webapp'
  • targetPath: '$(Pipeline.Workspace)/drop-webapp'
  • # 5. Execute deployment using extracted binaries
  • script: |
  • echo "Deploying $(Pipeline.Workspace)/drop-webapp to Staging Azure App Service..."
  • ls -la $(Pipeline.Workspace)/drop-webapp
  • displayName: 'Deploy Binaries to Cloud Host'
  • Practical AZ-400 Exam Scenarios & Anti-Patterns
  • Scenario 1: Pre-Release vs. Build Metadata Resolution in SemVer

Scenario: A developer defines a package dependency as ^2.1.0 . The internal feed contains 2.1.0 , 2.1.1 , 2.2.0-preview.1 , and 2.1.1+20260905.4 . During automated build restoration, which version does the client install?

AZ-400 Solution: The client installs 2.1.1 (or 2.1.1+20260905.4 indifferently). SemVer excludes pre-release versions ( -preview.1 ) from general ranges unless explicitly requested. Build metadata ( +20260905.4 ) has zero effect on precedence, meaning 2.1.1 and 2.1.1+... are mathematically equal. 2.2.0 would match ^2.1.0 , but because 2.2.0-preview.1 is an unstable pre-release, it is skipped.

Scenario 2: Pipeline Performance Degradation Due to Artifact Transfers

Scenario: An enterprise migration from on-premises TFS to Azure Pipelines experiences extremely slow pipeline runtimes. The build compiles 25,000 static files and passes them between three stages using PublishBuildArtifacts@1 and DownloadBuildArtifacts@0 . Transferring artifacts consumes 18 minutes per run.

AZ-400 Solution: Replace PublishBuildArtifacts@1 with PublishPipelineArtifact@1 and replace DownloadBuildArtifacts@0 with DownloadPipelineArtifact@2 . Pipeline Artifacts introduce parallelized multi-threaded uploads and chunk-level content deduplication, dramatically accelerating transfers for repositories with high file counts.

Loading diagram... Multi-Stage CI/CD Pipeline Flow with GitVersion and Deduplicated Pipeline Artifacts