Azure Artifacts for packages - Step-by-Step Execution

Process Flow - Azure Artifacts for packages

Create Azure DevOps Project

↓

Enable Azure Artifacts

↓

Create Feed (Package Repository)

↓

Publish Packages to Feed

↓

Consume Packages from Feed

↓

Manage Versions and Permissions

↓

Use in Builds and Releases

This flow shows how you create a project, enable Azure Artifacts, create a feed, publish and consume packages, manage versions and permissions, and finally use packages in your build and release pipelines.

Execution Sample

Azure

1. Create Azure DevOps project
2. Enable Azure Artifacts
3. Create a feed named 'MyFeed'
4. Publish package 'MyPackage' version 1.0.0
5. Consume 'MyPackage' in a pipeline

This sequence shows the basic steps to set up Azure Artifacts and use a package in your pipeline.

Process Table

Step	Action	Input/Condition	Result/Output
1	Create Azure DevOps project	Project name: 'DemoProject'	Project 'DemoProject' created
2	Enable Azure Artifacts	Enable in 'DemoProject'	Azure Artifacts enabled
3	Create feed	Feed name: 'MyFeed'	Feed 'MyFeed' created
4	Publish package	Package: 'MyPackage' v1.0.0	Package 'MyPackage' v1.0.0 published to 'MyFeed'
5	Consume package	Pipeline references 'MyPackage' from 'MyFeed'	Package downloaded and used in pipeline
6	Manage permissions	Add user 'DevUser' with read access	User 'DevUser' can read packages
7	Use in build	Build pipeline uses 'MyPackage'	Build succeeds using package
8	Exit	All steps completed	Azure Artifacts setup and usage complete

💡 All steps completed successfully, Azure Artifacts is ready and packages are used in pipelines

Status Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	After Step 5	Final
Project	None	DemoProject	DemoProject	DemoProject	DemoProject	DemoProject
Azure Artifacts Enabled	False	True	True	True	True	True
Feed	None	None	MyFeed	MyFeed	MyFeed	MyFeed
Package 'MyPackage' Version	None	None	None	1.0.0	1.0.0	1.0.0
User Permissions	None	None	None	None	None	Read for DevUser

Key Moments - 3 Insights

Why do we need to create a feed before publishing packages?

The feed acts like a storage place or library for packages. Without creating it first (see Step 3 in execution_table), there is nowhere to upload or organize packages.

Can a package be used in a pipeline before it is published?

No, the package must be published to the feed first (Step 4) so the pipeline can download it (Step 5). Trying to consume before publishing will fail.

How do permissions affect package usage?

Permissions control who can see or use packages. For example, adding read access for a user (Step 6) allows them to consume packages in their pipelines.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the package 'MyPackage' version 1.0.0 published?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Check the 'Action' and 'Result/Output' columns in execution_table rows for publishing packages

According to variable_tracker, when does Azure Artifacts become enabled?

A After Step 2

B After Step 3

C After Step 4

D After Step 1

💡 Hint

Look at the 'Azure Artifacts Enabled' row and see when it changes from False to True

If user 'DevUser' did not have read permission, what would change in the execution_table?

A Step 6 would show no permission added

B Step 4 would fail publishing

C Step 5 would fail consuming package

D Step 7 would succeed anyway

💡 Hint

Refer to Step 6 and Step 5 in execution_table about permissions and package consumption

Concept Snapshot

Azure Artifacts lets you store and share packages in Azure DevOps.
Create a project, enable Artifacts, then create a feed (package storage).
Publish packages to the feed, then consume them in pipelines.
Manage permissions to control access.
Use packages to share code and tools easily across teams.

Full Transcript

Azure Artifacts is a service in Azure DevOps that helps you store and share packages like code libraries. First, you create a project in Azure DevOps. Then you enable Azure Artifacts for that project. Next, you create a feed, which is like a folder or library where packages are stored. After that, you publish your package to the feed. Once published, you can use the package in your build or release pipelines by consuming it from the feed. Permissions let you control who can see or use the packages. This step-by-step process ensures your packages are organized, secure, and easy to use in your development workflows.