> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/artifact-registry/3.0/concepts/glossary.md).

# Glossary

Definitions for the core terms used throughout Harness Artifacts documentation, including registry, artifact, tag, digest, and lifecycle rule.

This glossary defines the terms you will encounter across Harness Artifacts documentation. Terms are listed alphabetically. Where a concept has a dedicated page, a link is provided to go deeper.

***

## Allowed patterns

A regex-based filter on a registry's **Artifact Filtering Rules** configuration. When one or more allowed patterns are set, only artifact names that match at least one pattern are accepted at push time. Artifact names that do not match any allowed pattern are refused. If no allowed pattern is configured, all names are accepted (subject to any blocked patterns). Allowed patterns and blocked patterns work together; allowed is evaluated first.

Go to [Set artifact filtering rules](https://developer.harness.io/artifact-registry/3.0/registries/set-artifact-filtering-rules.md) to configure them.

## Artifact

The named item stored in a registry, the thing itself, independent of any specific version. For a Docker registry, an artifact is an image name such as `payment-service`. For an npm registry, it is a package name such as `@my-org/auth-client`. An artifact groups all versions of that item together under one name. When you browse the **Artifacts** tab of a registry, each row is one artifact.

Go to [Artifact identity](https://developer.harness.io/artifact-registry/3.0/concepts/artifact-identity.md) for a detailed explanation of artifacts, versions, tags, and digests.

## Blocked patterns

A regex-based filter on a registry's **Artifact Filtering Rules** configuration. Artifact names that match a blocked pattern are refused at push time, regardless of allowed patterns. Use blocked patterns to prevent specific naming conventions, prefixes, or suffixes from entering a registry. For example, block any artifact whose name starts with `dev-` from entering a production registry.

Go to [Set artifact filtering rules](https://developer.harness.io/artifact-registry/3.0/registries/set-artifact-filtering-rules.md) to configure them.

## Cleanup rule

A lifecycle rule that evaluates artifact versions against deletion criteria, such as how old they are, how recently they were downloaded, or how many versions to keep, and soft-deletes the matching versions on a cron schedule. Cleanup rules never hard-delete immediately; deleted versions enter a recovery window during which they can be restored. Retention rules are always evaluated before cleanup rules and protect matching versions from deletion.

Go to [Lifecycle rules](https://developer.harness.io/artifact-registry/3.0/concepts/lifecycle-rules.md) for how cleanup and retention rules work together, and to [Create a cleanup rule](https://developer.harness.io/artifact-registry/3.0/lifecycle-management/create-a-cleanup-rule.md) to set one up.

## CVSS

Common Vulnerability Scoring System. A numerical scale from 0.0 to 10.0 that measures the severity of a software vulnerability. The score is computed from factors such as how easily the vulnerability can be exploited, whether it requires authentication, and what the impact on confidentiality, integrity, and availability is. Scores map to four severity bands: **Low** (0.1–3.9), **Medium** (4.0–6.9), **High** (7.0–8.9), and **Critical** (9.0–10.0). The Dependency Firewall CVSS Threshold policy uses this score to block or warn on inbound packages, and the Vulnerabilities tab uses it to categorize scan findings.

## Dependency Firewall

A policy enforcement layer that sits in front of upstream proxy registries. When a developer or pipeline requests a package through an upstream proxy with Dependency Firewall enabled, Harness evaluates the requested artifact against your configured policy sets before caching or returning it. A package that fails a policy can be blocked entirely (never cached) or cached but quarantined. Dependency Firewall evaluates packages from external sources. It does not apply to artifacts you push directly to a local registry.

Go to [Dependency Firewall](https://developer.harness.io/artifact-registry/3.0/concepts/dependency-firewall.md) for how evaluation works and the five built-in policy templates.

## Digest

An immutable cryptographic fingerprint of an artifact's exact content, expressed as `sha256:<hex-string>`. A digest is computed from the bytes of the artifact and cannot be changed after creation. It permanently identifies exactly those bytes and nothing else. Unlike a tag, a digest is never repointed to different content. Referencing a Docker image by digest in a Kubernetes manifest guarantees that every deployment uses the exact same image, regardless of what the tag currently points to.

Go to [Artifact identity](https://developer.harness.io/artifact-registry/3.0/concepts/artifact-identity.md) for when to use digests versus tags.

## Dry run

A lifecycle rule execution mode that evaluates the rule's criteria against the target registries and reports which artifact versions would be affected, without making any changes. Use a dry run before activating a new or modified rule on a production registry to verify that the scope and criteria are correct. The dry run result shows how many versions would be deleted, which are protected, and how much storage would be reclaimed.

Go to [Run a dry run](https://developer.harness.io/artifact-registry/3.0/lifecycle-management/run-a-dry-run.md) for how to trigger one.

## Exception / Exemption

A manual override that allows a blocked or quarantined artifact to be consumed despite a Dependency Firewall policy violation. Exceptions are reviewed and granted by a policy administrator. The **Exceptions** tab (at the URL `/exemptions`) tracks all pending, approved, rejected, and expired exceptions. The product uses both terms for the same concept: "exception" in the tab label and UI, and "exemption" in counts and URLs.

Go to [Request an exception](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/request-an-exception.md) and [Manage exceptions](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/manage-exceptions.md).

## Identity token

An authentication credential generated by the **Setup Client** flow in the Harness UI. Identity tokens are scoped to a specific registry and expire after a duration you choose at generation time (30 days, 90 days, 180 days, or custom). They are used as the password in HTTP basic auth when configuring a package manager (Docker, npm, Maven, pip, and other package managers) to authenticate against `pkg.harness.io`. For long-lived automation, use a service account token with a configured expiry instead.

Go to [Authentication and identity tokens](https://developer.harness.io/artifact-registry/3.0/concepts/authentication-and-identity-tokens.md) for token types, lifespan, and how pipeline identity affects authentication.

## Lifecycle rule

A reusable policy that automates artifact version management on a defined schedule. Two rule types exist: **cleanup rules** (delete versions that match criteria) and **retention rules** (protect versions from deletion). Rules are created at the account, organization, or project level and attached to one or more registries. Lifecycle rules apply to all artifact formats, including Docker, Maven, npm, and every other supported format.

Go to [Lifecycle rules](https://developer.harness.io/artifact-registry/3.0/concepts/lifecycle-rules.md) for the full concept, and to [Lifecycle Management](https://developer.harness.io/artifact-registry/3.0/lifecycle-management/overview.md) for task pages.

## Manifest

A JSON document that describes a container image: the ordered list of layers that compose the image, the image configuration, and the platform (OS and architecture). Docker and OCI images are stored as a manifest plus the individual layer blobs. A multi-architecture image uses an **index manifest**, a manifest of manifests, that lists architecture-specific manifests for each supported platform. The **Artifact Details** tab on a Docker version detail page shows the raw manifest.

## Package

A single software unit in a package-format registry, such as an npm package, a Maven artifact, a Python wheel, or a Cargo crate. In Harness Artifacts, "package" and "artifact" describe the same stored item; the Harness Artifacts (New Experience) UI uses "artifact" consistently. In ecosystems with their own terminology (Maven calls them artifacts, npm calls them packages), the Harness registry stores them under their ecosystem name but presents them uniformly as artifacts in the UI.

## Policy set

A named collection of one or more policies assigned a fail action and applied to a registry or upstream proxy. For **Dependency Firewall**, a policy set groups supply-chain policies (CVSS threshold, license policy, package age, OSS risk level, malicious package) and evaluates all of them on every inbound artifact. For **security scanning**, a Security Tests policy set defines the conditions, such as the presence of a Critical CVE, under which a pushed image is automatically quarantined. Multiple policy sets can be attached to a single registry.

Go to [Dependency Firewall](https://developer.harness.io/artifact-registry/3.0/concepts/dependency-firewall.md) and [Configure security scanning](https://developer.harness.io/artifact-registry/3.0/registries/configure-security-scanning.md) for how policy sets are used in each context.

## PURL

Package URL. A standardized format for uniquely identifying a software artifact across ecosystems, following the pattern `pkg:<type>/<namespace>/<name>@<version>`. Examples: `pkg:npm/%40my-org/auth-client@1.0.0`, `pkg:pypi/requests@2.31.0`, `pkg:docker/my-org/payment-service@sha256:a3c4…`. PURLs appear in SBOM reports, Dependency Firewall evaluation details, and vulnerability database entries. Because PURLs are ecosystem-agnostic, security tooling can use them to look up affected packages across registries, CVE databases, and SBOM documents without ecosystem-specific parsing.

Go to [Artifact identity](https://developer.harness.io/artifact-registry/3.0/concepts/artifact-identity.md) for how PURLs are used in SBOM and vulnerability management workflows.

## Quarantine

A reversible hold placed on an artifact that prevents it from being pulled by users or pipelines. Quarantine is not a deletion. The artifact remains visible in the registry and can be released after review. An artifact can be quarantined automatically when a security scan finds a policy violation (such as a Critical CVE), or when Dependency Firewall evaluates an inbound package as a Warning and the registry is configured to quarantine on warnings. Releasing from quarantine requires the **Manage Artifacts** permission.

Go to [Quarantine](https://developer.harness.io/artifact-registry/3.0/security-and-compliance/quarantine.md) for how to find, review, release, and delete quarantined artifacts.

## Registry

A named, typed store for artifacts of one specific format. Docker images go in a Docker registry. Maven artifacts go in a Maven registry. Every registry has a unique URL (`pkg.harness.io/<account>/<registry-name>/`) and exists at a scope, account, organization, or project, that determines who can access it. There are two registry kinds: **local registries** (store artifacts you push) and **upstream proxies** (cache artifacts from external sources).

Go to [Registries and upstream proxies](https://developer.harness.io/artifact-registry/3.0/concepts/registries-and-upstream-proxies.md) for the distinction between local registries and upstream proxies.

## Retention rule

A lifecycle rule that permanently protects matching artifact versions from deletion by any cleanup rule, manual soft delete, or scheduled purge. Retention rules are always evaluated before cleanup rules. A version that matches a retention rule is never a candidate for deletion, regardless of age, download history, or version count. Use retention rules to protect production tags, release versions, and any version that must never be removed automatically.

Go to [Lifecycle rules](https://developer.harness.io/artifact-registry/3.0/concepts/lifecycle-rules.md) and [Create a retention rule](https://developer.harness.io/artifact-registry/3.0/lifecycle-management/create-a-retention-rule.md).

## SBOM

**Software Bill of Materials**. A machine-readable inventory of every component inside a software artifact: the packages, their versions, their suppliers, the licenses they carry, and how they depend on each other. Harness generates an Software Bill of Materials (SBOM) automatically when a Docker or Helm image is pushed to a registry with security scanning enabled. SBOMs are available on the **SBOM** tab of the artifact version detail page and downloadable in **CycloneDX** or **Software Package Data Exchange (SPDX)** format. SBOMs are used for license audits, blast-radius analysis after a CVE is disclosed, and compliance submissions (US Executive Order 14028, EU Cyber Resilience Act).

Go to [SBOM and software supply chain](https://developer.harness.io/artifact-registry/3.0/concepts/sbom-and-supply-chain.md) and [SBOM: view, score, and download](https://developer.harness.io/artifact-registry/3.0/security-and-compliance/sbom-view-score-and-download.md).

## Scope

The level of the Harness organization hierarchy at which a resource, a registry, lifecycle rule, or permission, exists. Three scopes are available: **Account** (visible across the entire Harness account), **Organization** (visible within one organization in the account), and **Project** (visible only within a specific project). A pipeline can access registries in its own project and in parent scopes (its containing organization and account), but not in sibling projects. Shared resources such as base image proxies and account-wide lifecycle rules belong at the account scope; team-specific libraries belong at the organization or project scope.

## Setup Client

The configuration wizard is accessible from **Show more actions** (**⋮** > **Setup Client**) on any registry in the Harness UI. Setup Client generates the exact commands needed to authenticate a local package manager, such as Docker, npm, Maven, pip, Cargo, and others, against the selected registry. It creates a registry-scoped **identity token** with a configurable expiry (30 days, 90 days, 180 days, or custom) and displays the login and push/pull commands with your account details pre-filled. Run Setup Client once per registry per machine to configure your local development environment.

## Soft delete

A deletion mode in which an artifact version is removed from active use but retained in storage for a configurable recovery period before being permanently purged. During the recovery window, a soft-deleted version is not downloadable. Pull attempts return a 404, but it can be restored. Lifecycle cleanup rules always perform soft deletes; they never immediately and permanently remove content. The recovery window length is set in **Account Settings > Default Settings > Artifact Registry**. To remove a version immediately and permanently, use the **Permanently delete** option in the delete confirmation dialog.

Go to [Delete an artifact](https://developer.harness.io/artifact-registry/3.0/artifacts/delete-an-artifact.md) for soft delete behavior, restoration, and permanent deletion.

## Tag

A mutable, human-readable label that points to a specific version of an artifact. Tags give images and packages a human-readable name, such as `latest`, `stable`, `2.4.1`, but they can be moved: a new push to `latest` silently changes what that tag points to. In Docker, the same tag name applied to a new build replaces the previous reference. For production workloads where you need certainty about exactly what is running, use a digest instead of a tag.

Go to [Artifact identity](https://developer.harness.io/artifact-registry/3.0/concepts/artifact-identity.md) for a full comparison of tags versus digests.

## Terraform Backend

A registry type that stores Terraform state files and provides state locking through the Terraform HTTP backend protocol. Unlike the **Terraform** registry type, which stores modules and providers, a Terraform Backend registry acts as a remote state backend that `terraform init` and `terraform apply` use to read, write, and lock state during runs. The backend is configured in your Terraform root module with an `http` backend block pointing at the Harness backend endpoint.

Go to [Terraform Backend](https://developer.harness.io/artifact-registry/3.0/setup/terraform-backend.md) for setup and configuration.

## Upstream proxy

A registry kind that caches artifacts from an external source rather than storing artifacts you push. When a client requests a package through an upstream proxy, Harness checks its local cache first; on a hit, the cached artifact is returned immediately. On a miss, Harness fetches the artifact from the configured upstream source (Docker Hub, Maven Central, npm, PyPI, or a custom URL), caches it, and returns it to the client. Upstream proxies protect your builds from public registry outages, rate limits, and availability incidents.

Go to [Registries and upstream proxies](https://developer.harness.io/artifact-registry/3.0/concepts/registries-and-upstream-proxies.md) for local registry versus upstream proxy and how resolution order works.

## Version

A specific release of an artifact. Versions are what get pushed to a registry, scanned for vulnerabilities, deployed to environments, and cleaned up by lifecycle rules. For Docker images, a version is identified by a tag or digest. For package ecosystems (Maven, npm, PyPI, Cargo, and others), a version follows the ecosystem's versioning convention, such as a semantic version string like `2.4.1`, a snapshot identifier like `1.0.0-SNAPSHOT`, or a pre-release label like `1.0.0-beta.1`.

## Virtual registry (legacy)

A registry kind from earlier Artifacts versions that aggregated multiple upstream sources into a single pull endpoint. In Harness Artifacts (New Experience), this capability is replaced by attaching one or more upstream proxies to a local registry in a configurable priority order. Virtual registries are no longer created in the Harness Artifacts (New Experience) UI. If you encounter a virtual registry in an account migrated from an earlier version, it continues to function but cannot be created anew.

## Violation

A Dependency Firewall evaluation result indicating that an inbound artifact failed at least one policy in a policy set. Violations appear on the **Violations** tab of the Dependency Firewall view and record which policy failed, the verdict (Blocked or Warning), the artifact name and version, and the timestamp of the evaluation. A **Blocked** verdict means the artifact was not cached and cannot be consumed. A **Warning** verdict means the artifact was cached but flagged. It may optionally be quarantined depending on registry configuration.

Go to [View and triage violations](https://developer.harness.io/artifact-registry/3.0/dependency-firewall/view-and-triage-violations.md) for how to investigate and act on violations.

{% @harness-feedback/feedback %}
