I85PREP
⌘ K
JFrog Artifactory Certified DevOps Engineer study materials
JFrog Artifactory Certified DevOps Engineer study resources

JFrog Artifactory Certified DevOps Engineer practice questions

One question at a time. Build your JFrog Artifactory Certified DevOps Engineer understanding.

First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.

Continue in the practice tool above to load more questions, 50 at a time.

Question 1Repositories and Package Management

A platform team needs one URL that resolves artifacts from several local and remote repositories in a defined priority order. Which Artifactory repository type provides this?

  1. Virtual repository Correct answer.
  2. Federated repository
  3. Local repository
  4. Remote repository

Explanation

A virtual repository aggregates multiple local and remote repositories behind a single URL and resolves requests according to the order configured for those aggregated repositories. It does not store artifacts itself; it delegates storage and retrieval to the underlying repositories.

Question 2Repositories and Package Management

Which repository type caches artifacts fetched from an external registry such as Maven Central or Docker Hub?

  1. Local repository
  2. Remote repository Correct answer.
  3. Release bundle repository
  4. Virtual repository

Explanation

A remote repository acts as a proxy for an external package source. On the first request it fetches the artifact, stores a cached copy locally, and serves subsequent requests from that cache.

Question 3Repositories and Package Management

A CI pipeline uploads a newly built JAR that must be stored permanently in Artifactory. Which repository type is the direct storage location for that artifact?

  1. Local repository Correct answer.
  2. Distribution repository
  3. Virtual repository
  4. Remote repository

Explanation

A local repository is the physical storage location for artifacts that your organization produces and deploys. Virtual repositories only route requests, and remote repositories cache third-party artifacts rather than serving as the primary store for internal builds.

Question 4Repositories and Package Management

A custom package stores files at `org/name/version/name-version.tar.gz`. The Artifactory UI must show parsed coordinates for this path. Which configuration maps the path to package coordinates?

  1. A push replication trigger
  2. A property set attached to the repository
  3. A repository layout Correct answer.
  4. An include/exclude pattern on a virtual repository

Explanation

A repository layout defines path patterns and token placeholders that tell Artifactory how to derive module, artifact, version, and classifier coordinates from a file path. Assigning the layout to the repository enables coordinate parsing in the UI and REST API.

Question 5Repositories and Package Management

A virtual repository aggregates `libs-release-local` and `libs-snapshot-local`. Release requests must resolve from `libs-release-local` before any other aggregated repository is checked. What controls that behavior?

  1. The order of aggregated repositories Correct answer.
  2. The replication schedule on each local repository
  3. The package type assigned to the virtual repository
  4. The checksum policy on the virtual repository

Explanation

A virtual repository queries its aggregated repositories in the order they are listed in its configuration. The first repository that contains a matching artifact wins, so ordering is the mechanism for controlling resolution priority.

Question 6Repositories and Package Management

A remote repository must serve only artifacts that are already in its cache while an upstream registry is being maintained. Which setting enforces that behavior?

  1. Store Artifacts Locally
  2. Hard Fail
  3. Bypass HEAD requests
  4. Offline Correct answer.

Explanation

Marking a remote repository as Offline stops Artifactory from contacting the upstream source. Requests are satisfied only from artifacts already cached locally, and cache misses fail rather than triggering a remote fetch.

Question 7Repositories and Package Management

An administrator wants artifacts in a local repository pushed automatically to a secondary Artifactory instance for disaster recovery. Which replication setup accomplishes this?

  1. Push replication on the primary local repository Correct answer.
  2. Pull replication on the secondary local repository
  3. Remote repository replication on the secondary instance
  4. Virtual repository replication on the primary instance

Explanation

Push replication runs on the source repository and sends artifacts to a configured target Artifactory instance. Configuring it on the primary local repository pushes new artifacts to the secondary instance without waiting for the secondary to request them.

Question 8Repositories and Package Management

Which built-in Artifactory capability removes artifacts from a repository based on age and usage without requiring an external cron script?

  1. Garbage Collection
  2. Package Cleanup Correct answer.
  3. Trash Can
  4. Checksum Policy

Explanation

Package Cleanup policies let administrators define retention rules such as maximum age or unused duration and apply them to selected repositories, and Artifactory deletes matching artifacts on a schedule. Garbage Collection reclaims storage for already-deleted binaries; it does not decide which artifacts to remove.

Question 9Repositories and Package Management

After a new `.deb` package is deployed to a Debian local repository, which index must Artifactory recalculate so `apt` clients can resolve the package?

  1. `Packages.gz` Correct answer.
  2. `repomd.xml`
  3. `index.json`
  4. `maven-metadata.xml`

Explanation

Debian clients read the `Packages` index, commonly stored compressed as `Packages.gz`, to discover available packages and their checksums. Artifactory regenerates that index, along with the `Release` file, when the Debian repository index is recalculated.

Question 10Repositories and Package Management

Which statement accurately describes a federated repository in Artifactory?

  1. It mirrors a remote repository through scheduled pull replication only.
  2. It synchronizes a local repository bi-directionally across Artifactory instances. Correct answer.
  3. It proxies an external registry and caches artifacts on first request.
  4. It aggregates local and remote repositories behind a single URL.

Explanation

A federated repository is a local repository that participates in a federation of Artifactory instances. Members synchronize artifacts and metadata bi-directionally, so a deployment to any member becomes visible to the others without configuring separate push or pull replication jobs.

Question 11Repositories and Package Management

A platform team publishes Helm charts to a local Helm repository in Artifactory. Which file must Helm clients retrieve first to discover chart versions and their download locations?

  1. `Packages.gz`
  2. `repodata/repomd.xml`
  3. `maven-metadata.xml`
  4. `index.yaml` Correct answer.

Explanation

A Helm repository exposes a generated `index.yaml` that lists chart names, versions, and download URLs. Helm clients read that index when the repository is added and when dependencies are refreshed.

Question 12Repositories and Package Management

A developer wants npm to publish and install packages from a virtual npm repository named `npm-virtual` on host `art.example.com`. Which registry URL should be placed in the project `.npmrc`?

  1. `https://art.example.com/artifactory/api/nuget/npm-virtual`
  2. `https://art.example.com/artifactory/npm-virtual`
  3. `https://art.example.com/artifactory/webapp/#/artifacts/npm-virtual`
  4. `https://art.example.com/artifactory/api/npm/npm-virtual` Correct answer.

Explanation

Artifactory exposes npm registry access under `/artifactory/api/npm/<repository-key>`. The `.npmrc` registry value must use that API endpoint so npm can resolve package metadata and publish tarballs.

Question 13Repositories and Package Management

Which Artifactory repository type is appropriate for storing arbitrary binary files such as installer bundles and test fixtures that have no package-manager metadata format?

  1. A local Generic repository Correct answer.
  2. A remote Maven repository
  3. A federated Helm repository
  4. A virtual Docker repository

Explanation

A local Generic repository stores files as-is and does not require package-specific metadata or layout parsing. It still supports checksums, properties, and permissions, which makes it suitable for arbitrary binaries.

Question 14Repositories and Package Management

A team runs `mvn deploy` against a Maven virtual repository that aggregates several local and remote repositories. Which setting on the virtual repository determines where the deployed artifacts are actually stored?

  1. Include pattern
  2. Default deployment repository Correct answer.
  3. Remote repository cache period in minutes
  4. Snapshot version behavior

Explanation

A virtual repository is primarily a read-through aggregation, so deployments need an explicit target local repository. The Default Deployment Repository setting selects that target for Maven deployments through the virtual repository.

Question 15Repositories and Package Management

A Maven local repository is configured for unique snapshots with `Max Unique Snapshots` set to 5. A build deploys six distinct timestamped snapshot versions of the same artifact. What does Artifactory retain?

  1. The newest five unique snapshot versions and removes the oldest Correct answer.
  2. All six versions because snapshots are never deleted automatically
  3. Only the base `-SNAPSHOT` file and no timestamped versions
  4. The five most recently downloaded versions regardless of deployment time

Explanation

With unique snapshots, each deployment creates a separate timestamped version, and `Max Unique Snapshots` caps how many are kept. When the cap is exceeded, Artifactory removes the oldest unique snapshots so only the configured number remain.

Question 16Repositories and Package Management

A remote repository is configured with checksum policy `Fail`. During a download, the checksum calculated by Artifactory does not match the checksum published by the upstream repository. What is the result?

  1. Artifactory recalculates the upstream checksum and stores the corrected value
  2. Artifactory caches the artifact and logs a warning
  3. Artifactory serves the artifact from the remote without caching it
  4. Artifactory rejects the download and does not cache the artifact Correct answer.

Explanation

The `Fail` checksum policy makes Artifactory treat a checksum mismatch as a failed download. Because the artifact fails validation, it is not added to the remote repository cache.

Question 17Repositories and Package Management

An administrator configures a virtual repository with an include pattern of `com/acme/**` and an exclude pattern of `com/acme/internal/**`. Which request is served by this virtual repository?

  1. A request for `com/acme/internal/secret-1.0.jar`
  2. A request for `org/other/lib-1.0.jar`
  3. A request for `com/acme/public/lib-1.0.jar` Correct answer.
  4. A request for `com/acme` only when the artifact is cached

Explanation

Include patterns determine which paths the virtual repository may expose, and exclude patterns remove paths from that set. The `public` artifact matches the include path and does not match the internal exclude path, so it is served.

Question 18Repositories and Package Management

Which AQL query returns artifacts in repository `libs-release-local` whose `stage` property equals `prod`?

  1. `items.find({"repo":"libs-release-local","stage":"prod"})`
  2. `items.find({"repo":"libs-release-local","$stage":"prod"})`
  3. `items.find({"repo":"libs-release-local","properties.stage":{"$eq":"prod"}})`
  4. `items.find({"repo":"libs-release-local","@stage":{"$eq":"prod"}})` Correct answer.

Explanation

AQL distinguishes built-in fields from artifact properties by prefixing property names with `@`. An equality condition on a property is expressed with the `$eq` operator inside the property object.

Question 19Repositories and Package Management

A Maven repository is configured for non-unique snapshots. After a snapshot build is deployed, which statement describes how the artifact is represented?

  1. The deployed file is renamed to a release version, and snapshot metadata is removed.
  2. The deployed file is stored only in the remote cache until a release version is requested.
  3. Each deployment creates a new timestamped filename, and `maven-metadata.xml` maps the `-SNAPSHOT` coordinate to the latest timestamp.
  4. The deployed file keeps the `-SNAPSHOT` filename, and `maven-metadata.xml` records the timestamp and build number for resolution. Correct answer.

Explanation

Non-unique snapshot mode overwrites the same `-SNAPSHOT`-named artifact on each deployment instead of creating a new timestamped file. `maven-metadata.xml` still carries the latest timestamp and build number so Maven clients can resolve the snapshot coordinate.

Question 20Repositories and Package Management

A team uploads a new RPM to a local YUM repository in Artifactory. Which generated metadata do `yum` clients rely on to resolve the new package?

  1. `repodata/repomd.xml` Correct answer.
  2. `index.yaml`
  3. `maven-metadata.xml` used by Maven clients
  4. `Packages.gz` used by Debian clients

Explanation

YUM repositories publish repository metadata under `repodata`, with `repomd.xml` pointing to the primary and other metadata files. `yum` reads that metadata to discover packages and their dependencies.

Question 21Repositories and Package Management

A Maven client needs to discover which snapshot build numbers are available for `com.acme:app` in a local Maven repository. Which file does Artifactory maintain at the group/artifact level for this purpose?

  1. pom.xml
  2. app-1.0-SNAPSHOT.jar
  3. maven-metadata.xml Correct answer.
  4. settings.xml

Explanation

Artifactory maintains `maven-metadata.xml` at the group and artifact level to list available versions, including timestamped snapshot builds, and to record the latest and release values Maven clients use during resolution. The POM describes a single build, while settings.xml is client-side configuration rather than repository metadata.

Question 22Repositories and Package Management

A developer pushes the image `art.example.com/docker-local/acme/api:2.1` to Artifactory. Which path segment identifies the Artifactory repository key?

  1. docker-local Correct answer.
  2. acme
  3. api
  4. 2.1

Explanation

In an Artifactory Docker repository path, the first segment after the host or `/artifactory` context is the repository key; `acme/api` is the image name and `2.1` is the tag. The repository key in this path is therefore `docker-local`.

Question 23Repositories and Package Management

Two byte-identical JAR files are uploaded to two different local repositories under different paths. Which statement describes how Artifactory stores the binary content?

  1. The second upload is rejected because the checksum already exists.
  2. One blob is stored and both artifact nodes reference it. Correct answer.
  3. The second upload replaces the first artifact's path.
  4. Two complete copies are stored because the artifact paths differ.

Explanation

Artifactory uses checksum-based storage, so identical content is written once to the binary store and multiple artifact nodes can point to the same blob even when their repository paths differ. Deleting one artifact node does not remove the shared blob until no references remain.

Question 24Repositories and Package Management

An administrator needs artifacts from a primary Artifactory instance copied into a local repository on a disaster-recovery instance on a recurring schedule. Which replication mode should be configured on the disaster-recovery instance?

  1. Pull replication Correct answer.
  2. Federated repository
  3. Virtual repository
  4. Push replication

Explanation

Pull replication is configured on the target instance and periodically fetches artifacts from a remote repository on the source instance into a local repository. Push replication works in the opposite direction, sending artifacts from the source instance to the target.

Question 25Repositories and Package Management

A team stored JARs in a generic local repository and now needs Maven snapshot handling and Maven metadata. What is the correct way to make the repository behave as a Maven local repository?

  1. Convert the generic repository into a virtual Maven repository.
  2. Set the repository layout to maven-2-default and reindex the files.
  3. Create a Maven local repository and migrate the artifacts. Correct answer.
  4. Change the existing repository's package type to Maven in the UI.

Explanation

A repository's package type is fixed when the repository is created and determines the package-specific metadata and deployment behavior Artifactory applies. To gain Maven behavior, the team must create a Maven local repository and migrate the artifacts; changing only the layout does not add Maven package handling.

Question 26Repositories and Package Management

Which Artifactory repository type is purpose-built to host release bundles that JFrog Distribution sends to Edge nodes?

  1. Remote repository
  2. Virtual repository
  3. Distribution repository Correct answer.
  4. Federated repository

Explanation

A distribution repository is a repository type used with JFrog Distribution to store and serve release bundles destined for Edge nodes. It is distinct from local, remote, virtual, and federated repositories used for normal artifact resolution.

Question 27Repositories and Package Management

A Go build must resolve modules through an Artifactory remote Go repository at `https://art.example.com/artifactory/api/go/go-remote`. Which environment variable should the build set?

  1. GOPATH
  2. GOPROXY Correct answer.
  3. GO111MODULE
  4. GONOSUMDB

Explanation

`GOPROXY` tells the Go toolchain which module proxy URL to use for downloading modules, so it should point at the Artifactory Go repository endpoint. `GOPATH` sets the workspace, `GO111MODULE` toggles module mode, and `GONOSUMDB` controls checksum-database exclusions.

Question 28Repositories and Package Management

A Python team configures pip to install packages from an Artifactory PyPI repository. Which key in `pip.conf` specifies the primary repository URL?

  1. index-url Correct answer.
  2. extra-index-url
  3. no-index
  4. trusted-host

Explanation

`index-url` sets the primary package index that pip queries, so it should be the Artifactory PyPI repository URL. `extra-index-url` adds a secondary index, `trusted-host` marks a host as trusted for HTTP, and `no-index` disables index use entirely.

Question 29Repositories and Package Management

When npm installs a package from an Artifactory npm repository, which metadata document does Artifactory return so npm can resolve versions and tarball URLs?

  1. The package-lock.json
  2. The repository's index.yaml
  3. The packument JSON Correct answer.
  4. The npm-shrinkwrap.json

Explanation

npm registries return a JSON metadata document, commonly called a packument, that lists versions, dist-tags, and tarball URLs for a package. Artifactory serves this document from its npm repository so npm can select a version and download the corresponding tarball.

Question 30Repositories and Package Management

A remote repository caches artifacts from an upstream registry. Which setting controls how long Artifactory treats a cached artifact as fresh before it checks the upstream again?

  1. Offline Mode
  2. Cache Period Correct answer.
  3. Max Unique Snapshots
  4. Retention Policy

Explanation

The Cache Period on a remote repository defines the interval during which Artifactory considers a cached artifact fresh and can serve it without contacting the upstream registry. After the period expires, Artifactory revalidates the artifact with the remote source.

Question 31Repositories and Package Management

An enterprise runs Artifactory in three regions and wants one repository where a team can push an artifact to any instance and have it automatically available on the other instances without configuring push or pull replication jobs. Which repository type provides this behavior?

  1. Local repository
  2. Federated repository Correct answer.
  3. Remote repository
  4. Virtual repository

Explanation

Federated repositories form a bidirectional federation between Artifactory instances and synchronize artifacts pushed to any member, removing the need for per-instance replication jobs. Local, remote, and virtual repositories operate within a single instance and do not provide multi-site write propagation. The other types serve hosted, proxied, or aggregated content respectively.

Question 32Repositories and Package Management

An administrator enables the Offline setting on a remote repository that proxies an upstream Maven mirror. What happens when a build requests an artifact that is not yet in the local cache?

  1. Artifactory deletes the remote repository and recreates it as a local repository.
  2. Artifactory contacts the upstream mirror only for release artifacts and blocks snapshot requests.
  3. Artifactory serves cached artifacts but does not contact the upstream mirror for the missing artifact. Correct answer.
  4. Artifactory redirects the client to the upstream mirror URL for the missing artifact.

Explanation

The Offline flag stops a remote repository from making outbound requests to its upstream URL, so only content already in the cache can be resolved. Unresolved requests fail instead of being fetched or redirected. This is commonly used during upstream outages or maintenance windows.

Question 33Repositories and Package Management

A DevOps team needs to push internal container images to Artifactory with `docker push`. Which repository is the direct storage target for the image layers and tags?

  1. A Docker virtual repository
  2. A Docker remote repository
  3. A Docker local repository Correct answer.
  4. A generic local repository configured with a Docker layout

Explanation

Docker pushes are stored in a Docker local repository, which implements the registry API and hosts the manifests and layers. A remote repository is a read-only proxy, and a virtual repository can accept pushes only by forwarding them to a default deployment repository. A generic local repository cannot serve the Docker registry protocol even if a layout is assigned.

Question 34Repositories and Package Management

An Artifactory Debian repository is configured with distribution `bookworm` and component `main`. A Debian client fetches the compressed package index for the `amd64` architecture. Which repository path does the client request?

  1. dists/bookworm/main/binary-amd64/Packages.gz Correct answer.
  2. dists/main/bookworm/binary-amd64/Packages.gz
  3. bookworm/main/amd64/Packages.gz
  4. pool/bookworm/main/amd64/Packages.gz

Explanation

Debian repository indexes follow the `dists/<distribution>/<component>/binary-<architecture>/Packages.gz` convention, while package files themselves reside under `pool/`. The other paths either place the component and distribution in the wrong order or omit the required `dists` and `binary-` segments.

Question 35Repositories and Package Management

A virtual repository is configured with members in this order: local `libs-a`, remote `central-proxy`, local `libs-b`. The same artifact path exists in `libs-a` and `libs-b`. Which copy does Artifactory return for a client request through the virtual repository?

  1. Both copies are returned and the client chooses the newest.
  2. The copy in `libs-b`, because local repositories are resolved after remotes.
  3. The copy in `central-proxy`, because remote repositories always take precedence.
  4. The copy in `libs-a`, because it appears first in the member order. Correct answer.

Explanation

A virtual repository resolves an artifact by searching its member repositories in the configured order. The first member that contains the requested path provides the response, so `libs-a` wins over `libs-b` when both contain it. Artifactory does not return multiple copies for the client to choose.

Question 36Repositories and Package Management

In NuGet v3, which document does a client retrieve first from an Artifactory NuGet repository to discover the resource URLs for package search and publishing?

  1. The `packages.config` file of the solution
  2. The service index (`index.json`) Correct answer.
  3. The `.nupkg` package archive
  4. The `.nuspec` manifest of a specific package

Explanation

NuGet v3 clients start from a service index, typically `index.json`, which lists the resource endpoints such as search, registration, and push. The client then calls those endpoints; `.nupkg` and `.nuspec` files describe package content, not the feed's service endpoints. `packages.config` is a project-level dependency file, not a repository discovery document.

Question 37Repositories and Package Management

A repository cleanup policy is configured with a 30-day retention period and the Dry Run option enabled. What is the result of the next policy run?

  1. Matching artifacts are reported but not deleted, allowing the administrator to review the impact. Correct answer.
  2. Matching artifacts are moved to the trash and can be restored for 30 days.
  3. The policy skips all artifacts because Dry Run disables retention evaluation.
  4. Matching artifacts are deleted immediately and the policy is disabled.

Explanation

Dry Run executes the cleanup policy's matching logic and reports which artifacts would be removed without actually deleting them. This lets an administrator validate retention rules before enabling destructive cleanup. A normal run, with Dry Run off, performs the actual deletion according to the policy.

Question 38Repositories and Package Management

A team wants Terraform to resolve private modules and public modules through a single Artifactory URL while caching public modules. Which repository design meets this requirement?

  1. A single remote Terraform repository with private modules uploaded directly to it.
  2. A virtual Terraform repository containing only remote repositories, with private modules stored in a Docker local repository.
  3. One generic local repository for both private and public modules.
  4. A local Terraform repository for private modules and a remote Terraform repository for public modules, aggregated by a virtual Terraform repository. Correct answer.

Explanation

A virtual Terraform repository can aggregate a local repository for private modules and a remote repository that proxies and caches the public registry. Clients then use one virtual URL and resolution falls through to the appropriate member. A remote repository is not writable for private modules, and generic or Docker repositories do not provide Terraform module resolution semantics.

Question 39Repositories and Package Management

A build repeatedly requests an artifact path that does not exist upstream. Artifactory receives a 404 once and then returns 404 to later clients without contacting the upstream again for a period. Which remote repository setting controls that period?

  1. Socket Timeout
  2. Metadata Retrieval Cache Period
  3. Negative Cache TTL Correct answer.
  4. Unused Artifacts Cleanup Period

Explanation

Negative Cache TTL defines how long Artifactory caches a negative response, such as a 404, so repeated requests for a missing path do not hit the upstream each time. Metadata Retrieval Cache Period applies to cached metadata freshness, while socket timeout and cleanup periods govern other behaviors. Tuning Negative Cache TTL reduces upstream load but can delay visibility of newly published artifacts.

Question 40Repositories and Package Management

An upstream HTTP server rejects HEAD requests with 405, so an Artifactory remote repository cannot download artifacts even though GET requests work. Which remote repository setting should be enabled to resolve this?

  1. Propagate Query Parameters
  2. Hard Fail
  3. Offline
  4. Bypass HEAD Requests Correct answer.

Explanation

Some remote HTTP servers do not support HEAD, which Artifactory may use to check artifact existence before downloading. Enabling Bypass HEAD Requests makes Artifactory skip those checks so GET-based downloads can proceed. Offline, Hard Fail, and query parameter propagation address different proxy behaviors and do not solve a 405 on HEAD.

Question 41Platform Architecture, Installation and Configuration

An Artifactory administrator wants a single repository URL that aggregates a local release repository and a remote repository proxying Maven Central. Which repository type should be created?

  1. Federated repository
  2. Virtual repository Correct answer.
  3. Remote repository
  4. Local repository

Explanation

A virtual repository presents a single logical URL that aggregates local, remote, and other repositories without storing artifacts itself. It lets clients resolve artifacts from all included repositories through one endpoint. Local and remote repositories must already exist and are added to the virtual repository's resolution list.

Question 42Platform Architecture, Installation and Configuration

In a default Artifactory 7 installation, which binary provider is used for the filestore unless another provider is configured?

  1. Azure Blob Storage
  2. File system Correct answer.
  3. Amazon S3
  4. Google Cloud Storage

Explanation

The default binary provider stores artifacts on the local file system under the Artifactory data directory. S3, Google Cloud Storage, and Azure Blob Storage are optional providers configured for shared or cloud storage. The default provider requires no external object storage service.

Question 43Platform Architecture, Installation and Configuration

Where is the Artifactory master key stored by default in an Artifactory 7 installation rooted at $JFROG_HOME?

  1. $JFROG_HOME/artifactory/var/data/security/master.key
  2. $JFROG_HOME/artifactory/etc/master.key
  3. $JFROG_HOME/artifactory/var/etc/access/master.key
  4. $JFROG_HOME/artifactory/var/etc/security/master.key Correct answer.

Explanation

In Artifactory 7, the master key is stored under the security configuration directory at $JFROG_HOME/artifactory/var/etc/security/master.key. The master key encrypts sensitive configuration values and must be preserved across backups and HA nodes. Losing it can make encrypted values unrecoverable.

Question 44Platform Architecture, Installation and Configuration

Which Artifactory 7 component acts as the single entry point for incoming HTTP traffic and routes requests to the appropriate microservice?

  1. Metadata
  2. Access
  3. Event
  4. Router Correct answer.

Explanation

The JFrog Router is the front-door service that receives platform requests and routes them to the correct Artifactory microservice. It centralizes request routing so clients do not need to address individual services directly. Access, Metadata, and Event provide supporting platform functions rather than request routing.

Question 45Platform Architecture, Installation and Configuration

An engineer must configure Artifactory to store binaries in an S3 bucket instead of the default file system. Which file is edited to define the S3 binary provider?

  1. artifactory.config.xml
  2. system.yaml
  3. access.config.xml
  4. binarystore.xml Correct answer.

Explanation

The binarystore.xml file defines the binary provider chain, including S3 bucket, credentials, and related settings. system.yaml covers platform and shared service configuration, while artifactory.config.xml holds repository and system configuration imported by Artifactory. Changing the binary provider requires editing the binary store configuration.

Question 46Platform Architecture, Installation and Configuration

Two different repositories receive uploads of the same 100 MB artifact with an identical checksum. How does Artifactory's checksum-based filestore handle the binary content?

  1. It stores two physical copies because repositories are isolated
  2. It stores the second copy only if the repositories use different package types
  3. It stores one physical copy and creates separate database references Correct answer.
  4. It rejects the second upload as a duplicate

Explanation

Artifactory uses checksum-based storage, so identical binary content is stored only once in the filestore. Each repository upload gets its own database reference and metadata, but the underlying payload is shared. This deduplication reduces storage consumption across repositories.

Question 47Platform Architecture, Installation and Configuration

Which JFrog platform service centralizes authentication, authorization, and token management for Artifactory and other JPD services?

  1. Router
  2. Metadata
  3. Event
  4. Access Correct answer.

Explanation

The Access service provides centralized authentication, authorization, user management, and token handling for the JFrog Platform. Other services delegate security decisions to Access rather than maintaining independent user stores. This centralization keeps permissions consistent across platform services.

Question 48Platform Architecture, Installation and Configuration

When Artifactory is placed behind an external reverse proxy that terminates TLS, which request headers should the proxy set so Artifactory generates correct redirect and callback URLs?

  1. X-Forwarded-Proto and X-Forwarded-Port Correct answer.
  2. Host and Content-Type
  3. Authorization and WWW-Authenticate
  4. Accept-Encoding and User-Agent

Explanation

A TLS-terminating reverse proxy should forward the original scheme and port so Artifactory can build correct absolute URLs. X-Forwarded-Proto and X-Forwarded-Port are the standard headers for this purpose. Without them, Artifactory may generate HTTP URLs or incorrect ports in redirects and callbacks.

Question 49Platform Architecture, Installation and Configuration

A team is adding a second node to an Artifactory 7 HA cluster that already uses a shared PostgreSQL database and a shared S3 binary store. Which items must be identical on the new node for it to join and serve traffic correctly?

  1. Node ID and local filestore path
  2. Master key and join key Correct answer.
  3. JVM heap size and garbage collection schedule
  4. Router port and Access port

Explanation

HA nodes must share the same master key so encrypted configuration can be decrypted consistently, and they must use the same join key to establish trust within the platform. The shared database and binary store provide common state, but the cryptographic keys must also match. Local paths and runtime tuning can differ between nodes.

Question 50Platform Architecture, Installation and Configuration

A repository containing 500 GB of artifacts is deleted from Artifactory. What happens to the binary content in the filestore immediately after the repository deletion, before garbage collection runs?

  1. The binaries are deleted immediately because repository deletion removes the filestore directory
  2. The binaries remain until garbage collection identifies and removes unreferenced content Correct answer.
  3. The binaries are retained only if they are also referenced by a remote repository
  4. The binaries are moved to the trash repository automatically

Explanation

Deleting a repository removes its metadata and database references, but the physical binaries can remain in the filestore. Garbage collection later scans for unreferenced binary content and removes it. This design avoids deleting shared blobs that may still be referenced elsewhere.