Promoting Packages in Azure DevOps Artifacts

Promoting Packages in Azure DevOps Artifacts

In Azure Artifacts, promoting packages refers to the process of moving a package from one stage of the software development lifecycle to another. This typically involves promoting packages from pre-release or development feeds to more stable, production-ready feeds as the package is tested and validated through different environments (e.g., development, staging, production).

Promoting packages ensures that the right version of a package is used in the appropriate environments, and it helps manage the lifecycle of packages. This process is an integral part of Continuous Integration (CI) and Continuous Delivery (CD) pipelines, where packages are moved between environments in a controlled and automated manner.

Key Concepts for Package Promotion in Azure Artifacts

1. Package Feeds:

A feed in Azure Artifacts is a container for storing and managing packages. Feeds can be scoped to different views (Local, Prerelease, Release) to reflect the state of the package and control access and visibility.

2. Promotion Stages:

• Pre-release stages (Local/Prerelease views): These stages are typically used during development and testing. Packages here are often unstable or experimental.

• Release stage (Release view): This is where stable, production-ready packages reside, after they have been thoroughly tested in pre-release environments.

3. Promotion Workflow:

Promotion typically involves moving a package from a local or pre-release feed to a release feed after successful testing or validation in the staging or testing environments.

For example, a package may be initially pushed to a Prerelease feed, and once it passes testing, it is promoted to a Release feed for production use.

Why Promote Packages?

1. Quality Assurance:

To ensure that packages are only promoted to production after being properly tested and validated in earlier environments.

2. Consistency:

To maintain a controlled versioning process where the versions of packages used in different environments (e.g., dev, staging, prod) are properly managed and tracked.

3. Continuous Integration/Continuous Deployment (CI/CD):

Promoting packages aligns with CI/CD workflows, ensuring that the correct versions are automatically pushed to the appropriate environments at each stage.

4. Access Control:

To ensure that only tested and approved versions of a package are available to consumers in production environments.

Steps for Promoting Packages in Azure Artifacts

1. Set Up Multiple Feeds

Before you can promote packages, ensure you have multiple feeds in Azure Artifacts to represent different stages of your lifecycle (e.g., development, staging, and production). You may have a Prerelease feed for testing and a Release feed for stable, production-ready packages.

You can set up feeds in Azure DevOps by navigating to Artifacts > + New Feed.

Example: MyApp-Dev, MyApp-Staging, MyApp-Release.

2. Publish Packages to Initial Feed (Development or Pre-release)

Packages are usually published to a local or prerelease feed first, as they are being developed and tested.

For example, a 1.0.0-alpha version might be pushed to a Prerelease feed:

xxxxxxxxxx
3
1
# Example for publishing a NuGet package to a prerelease feed
2
dotnet pack --version 1.0.0-alpha
3
dotnet nuget push MyPackage.1.0.0-alpha.nupkg --source https://dev.azure.com/{organization}/_packaging/{feed}/nuget/v3/index.json

3. Promote Packages After Testing and Validation

Once a package has undergone internal testing, the next step is to promote it to the Release feed. You can automate this process as part of a CI/CD pipeline.

Here’s how you can promote a package:

1. Manual Promotion:

If not automated, you can manually move packages by re-publishing them to the target feed with a new version or the same version if no further changes are needed.

For example, a package 1.0.0-alpha might be tested and then promoted to a Release feed as 1.0.0.

xxxxxxxxxx
2
1
# Push the tested package to the release feed
2
dotnet nuget push MyPackage.1.0.0.nupkg --source https://dev.azure.com/{organization}/_packaging/{ReleaseFeed}/nuget/v3/index.json

2. CI/CD Automation:

You can automate the promotion as part of a pipeline that runs after a successful build and testing phase. For instance, in Azure Pipelines, you can define tasks that publish the package to the target feed after passing the necessary tests.

4. Manage Versioning During Promotion

When promoting packages, it’s important to follow Semantic Versioning (SemVer), where the major, minor, and patch numbers are updated based on the type of changes made.

Promotion Example:

1.0.0-alpha (in the prerelease stage) –> 1.0.0 (after testing and validation).

If there are breaking changes in the next stage, increment the major version (e.g., 2.0.0).

5. Consume Promoted Packages in Different Environments

Once a package has been promoted to the Release feed, it can be consumed by different teams, projects, or environments. In Azure Pipelines, you can use these packages as dependencies in your builds.

For example, in an npm package, after promotion, it might be installed in the production build pipeline as:

xxxxxxxxxx
1
1
npm install @myorg/my-package@1.0.0 --registry https://pkgs.dev.azure.com/{organization}/_packaging/{ReleaseFeed}/npm/registry/

This ensures that only stable, production-ready versions are consumed in the final build.

Best Practices for Promoting Packages

1. Use Semantic Versioning:

Follow SemVer to indicate the stability of packages clearly (e.g., 1.0.0 for production, 1.0.0-alpha for pre-release).

2. Automate the Promotion Process:

Automate package promotion using Azure Pipelines to ensure consistency and reduce the risk of manual errors. For example, use a pipeline that promotes packages from Prerelease to Release after successful tests.

3. Control Access to Feeds:

Use Azure Artifacts permissions to control who can publish and consume packages from each feed.

Only trusted team members should be able to push packages to the Release feed.

4. Test Packages in Staging:

Always test packages in a staging environment before promoting them to production. This reduces the risk of bugs and instability in production.

5. Monitor and Rollback:

Monitor the usage of promoted packages. In case of issues, Azure Artifacts supports the unpublish functionality (though, once versions are published, they cannot be edited, so the best practice is to always increment versions).

Automating Package Promotion with Azure Pipelines

You can set up an Azure Pipeline to automate the promotion of packages after successful tests. Here's a simple workflow:

1. Create a Build Pipeline:

In your build pipeline, build the package and push it to a Prerelease feed.

xxxxxxxxxx
27
1
trigger:
2
  branches:
3
    include:
4
      - main
5
jobs:
6
  - job: Build
7
    pool:
8
      vmImage: 'ubuntu-latest'
9
    steps:
10
      - task: NuGetCommand@2
11
        inputs:
12
          command: restore
13
          restoreSolution: '**/.sln'
14
      - task: DotNetCoreCLI@2
15
        inputs:
16
          command: 'build'
17
          projects: '**/.csproj'
18
      - task: DotNetCoreCLI@2
19
        inputs:
20
          command: 'publish'
21
          publishWebProjects: false
22
          arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)'
23
      - task: NuGetCommand@2
24
        inputs:
25
          command: 'push'
26
          packagesToPush: '$(Build.ArtifactStagingDirectory)/.nupkg'
27
          nuGetFeed: '$(NuGetFeed)'

2. Create a Release Pipeline:

After the package has passed tests in the build pipeline, set up a Release Pipeline that promotes the package to a Release feed.

xxxxxxxxxx
8
1
jobs:
2
  - job: PromotePackage
3
    steps:
4
      - task: NuGetCommand@2
5
        inputs:
6
          command: push
7
          packagesToPush: '$(Build.ArtifactStagingDirectory)/.nupkg'
8
          nuGetFeed: '$(ReleaseFeed)'

Summary

Promoting packages in Azure Artifacts is an essential step in maintaining the lifecycle and quality of your packages as they move from development to production. By using multiple feeds for different environments, adhering to semantic versioning, and automating the process with Azure Pipelines, you can ensure that only stable and tested packages are deployed to production.

Key Steps:

1. Publish packages to initial feeds (Local/Prerelease).

2. Promote packages to stable feeds (Release).

3. Automate the promotion process using CI/CD pipelines.

4. Control access and track versions to maintain consistency across environments.

By following best practices and leveraging automation, you can streamline the promotion process and improve the stability and security of your software releases.