Chapter 22Lesson 05240–330 min

Checkpoint Lab — Sonatype IQ Integration, Component Intelligence, Quarantine, Policy Evaluation, and Procurement Controls

Run a complete fixture-driven procurement review: predict policy outcomes, evaluate several synthetic components, approve one bounded exception, prove exactly what changed, assemble an evidence packet, and map the exercise to a licensed Nexus Repository Firewall deployment.

CheckpointProcurementEvidence packetWaiverRunbook

Learning objectives

  • Translate a procurement policy into a bounded exception SLA.
  • Predict allow/quarantine outcomes before executing the local evaluator.
  • Approve one exact, expiring waiver without changing underlying intelligence evidence.
  • Produce an auditable evidence packet and verification checklist.
  • Map every local state transition to the corresponding licensed Nexus/IQ/Firewall boundary.
Version/product baseline (27 August 2026). The dated Nexus reference line is 3.95.2-01 with Java 21. The current IQ Server GA line is 206 (released 5 August 2026). For Nexus 3.94.0+, Firewall is configured on supported repositories with repository-level Audit Only, Quarantine, or PCCS modes. Re-check live release notes before applying UI/API details.
License boundary. Repository Firewall is not bundled into Community Edition merely because CE can connect to it. Sonatype documents Firewall as working with Nexus Repository Community or Pro when the deployment also has an IQ Server/Firewall service with a valid Repository Firewall license. Mandatory exercises in this chapter use synthetic fixtures only; no paid service is required.
Safety boundary. Never point policy experiments at production proxy repositories, disable Firewall to unblock a build, create broad waivers, expose IQ/Nexus credentials, or use real employer component names. Use synthetic component identifiers, loopback files, fake users, and documented review evidence.

1. Scenario and operating rules

You are the artifact-platform engineer for a small organization introducing third-party procurement controls. There is no commercial Firewall license in this mandatory lab. Security has supplied a synthetic policy, development has supplied four candidate components, and one component has a temporary compatibility requirement. Your job is to classify the candidates, preserve evidence, and approve only the narrow exception authorized by the scenario.

Checkpoint rule. Never change components.json to make a blocked component look safe. Policy decisions, waivers, and evidence snapshots are separate artifacts. That mirrors the production requirement to preserve facts while recording governance decisions.

2. Preflight and exact assumptions

Area Checkpoint assumption
Nexus reference 3.95.2-01 / Java 21 for terminology and current 3.94+ Firewall mode model; no live Nexus required.
IQ reference IQ Server 206 is the dated current GA reference; no IQ service required.
Edition/license Mandatory path is free fixture simulation. Live Firewall is optional and requires a valid Repository Firewall license.
Database/blob No database/blob mutation. If mapped to Nexus, admitted proxy content would create ordinary DB metadata + blob bytes.
Client/network Local files only; no public registry, production endpoint, or employer namespace.
Secrets None. Any optional live credential must remain outside lesson files and evidence output.

3. Setup the evidence directory

mkdir -p chapter22-checkpoint/evidence
cd chapter22-checkpoint

On PowerShell:

New-Item -ItemType Directory -Force chapter22-checkpoint/evidence | Out-Null
Set-Location chapter22-checkpoint

Copy the Lesson 2 evaluate.py into this directory. Use the following fresh checkpoint fixtures so the evidence is independent from the guided lab.

4. Candidate components

[
  {"id":"pkg:maven/com.example/alpha@1.0.0","securityRisk":1,"license":"approved","malware":"none"},
  {"id":"pkg:maven/com.example/bravo@2.4.0","securityRisk":8,"license":"approved","malware":"none"},
  {"id":"pkg:maven/com.example/charlie@3.2.1","securityRisk":5,"license":"review","malware":"none"},
  {"id":"pkg:maven/com.example/delta@0.9.0","securityRisk":10,"license":"approved","malware":"synthetic-positive"}
]

Save as components.json. Use the same policy rules as Lesson 2 and start with waivers.json containing [].

5. Prediction gate — write this before execution

Create evidence/predictions.md with your expected result and reason for each component. At minimum, predict these two important state transitions:

  1. Bravo will move into a synthetic quarantine disposition because of HIGH_SECURITY_RISK; no Nexus blob/database state changes in the fixture lab.
  2. After a valid waiver for Bravo only, Bravo’s disposition will change to allow while its securityRisk=8 evidence remains unchanged and Charlie/Delta remain quarantined.

Also predict Alpha=allow, Charlie=quarantine for license review, and Delta=quarantine for both malware fixture + high risk.

6. First policy evaluation

python evaluate.py | tee evidence/evaluation-before-waiver.json

If your shell does not provide tee, run python evaluate.py and copy the generated results.json to evidence/evaluation-before-waiver.json. Verify the expected disposition matrix before proceeding.

Candidate Expected failing evidence Decision
Alpha None Allow
Bravo HIGH_SECURITY_RISK Quarantine
Charlie LICENSE_REVIEW Quarantine
Delta MALWARE_FIXTURE + HIGH_SECURITY_RISK Quarantine

7. Procurement review: evaluate alternatives before waiver

The scenario authorizes a temporary exception only for Bravo because an internal compatibility test cannot complete before the release window. Before waiving, document:

  • Why Alpha cannot replace Bravo.
  • Why the release cannot wait for a lower-risk Bravo version.
  • Which team owns migration/remediation.
  • Why seven days is sufficient.
  • What happens when the waiver expires.

Do not waive Charlie or Delta. Charlie needs a license review; Delta represents a synthetic malware-positive fixture and also fails high-risk policy.

8. Apply the exact waiver

[
  {
    "component":"pkg:maven/com.example/bravo@2.4.0",
    "rule":"HIGH_SECURITY_RISK",
    "owner":"team-bravo-example",
    "reviewer":"procurement-reviewer-example",
    "reason":"Seven-day compatibility exception while replacement is validated",
    "ticket":"LAB-22-CP-001",
    "expiresAt":"2026-09-03T00:00:00Z"
  }
]

Save as waivers.json. Re-run the evaluator and preserve the output:

python evaluate.py
cp results.json evidence/evaluation-after-waiver.json

PowerShell: Copy-Item results.json evidence/evaluation-after-waiver.json.

9. Prove exactly what changed

  • Bravo: decision changes from quarantine to allow.
  • Bravo: securityRisk remains 8 in components.json.
  • Alpha stays allowed.
  • Charlie stays quarantined.
  • Delta stays quarantined with both failing violations.
  • No binary artifact, Nexus DB row, blob object, repository config, public upstream, or real policy service was touched.

This is the central governance lesson: the waiver changes disposition, not history or evidence.

10. Build the evidence packet

Your final directory should contain:

evidence/
├── predictions.md
├── evaluation-before-waiver.json
├── evaluation-after-waiver.json
├── waiver-review.md
├── product-boundary.md
└── verification.md

In waiver-review.md, record component, failing rule, owner, reviewer, reason, ticket, expiry, and remediation action. In product-boundary.md, record that the lab is a simulation and list the current Nexus/IQ reference versions and licensed Firewall requirement. In verification.md, record every checklist result below.

11. Map each checkpoint action to licensed product behavior

Checkpoint action Licensed deployment analogue Persistent state
Read components.json Component identified/evaluated by IQ/Firewall intelligence. IQ/Firewall evaluation evidence, not Nexus blob bytes.
Apply policy.json Configured IQ/Firewall policy action. Policy configuration/version.
Decision=quarantine New proxy request held/blocked by Firewall Quarantine mode. Quarantine/result evidence + Nexus request context.
Add exact waiver Authorized waiver/release workflow. Waiver scope, reason, owner/reviewer, expiry.
Decision=allow Component may be admitted/served subject to repository behavior. Nexus component/asset metadata + blob content when actually cached.

12. Optional licensed extension

Only in an authorized disposable environment:

  1. Confirm Nexus 3.94+ and IQ/Firewall connection/license.
  2. Create or identify a disposable supported proxy repository.
  3. Start in Audit Only; capture the configured mode and repository results.
  4. If the organization explicitly authorizes a quarantine demonstration, use a harmless component selected for a known lab policy—not a real malicious package—and preserve evidence.
  5. Use the product’s supported waiver/release workflow only for the disposable test.
  6. Return the repository to its approved baseline and remove test waivers/resources.
Do not seek real malware for this lab. A fixture-driven policy violation teaches the enforcement workflow without introducing hazardous or untrusted software into the environment.

13. Verification checklist

  • Predictions were written before execution.
  • All four candidate identities are synthetic com.example components.
  • Policy version is recorded.
  • First evaluation matches expected allow/quarantine results.
  • Exactly one waiver exists and it has owner, reviewer, reason, ticket, and expiry.
  • Second evaluation changes only Bravo’s disposition.
  • Underlying risk/license/malware fixture fields remain unchanged.
  • Evidence packet does not contain credentials, real employer namespaces, or production URLs.
  • Licensed mapping clearly distinguishes Nexus database/blob state from IQ/Firewall policy state.
  • Cleanup removes only the disposable checkpoint directory or authorized live lab resources.

14. Cleanup / rollback

For the mandatory fixture lab, archive the evidence if desired and delete chapter22-checkpoint. No external rollback is needed. For an optional live lab, remove the test waiver, restore the repository’s approved Firewall mode, remove only disposable test repositories/resources, verify ordinary clients still use the governed endpoint, and preserve a redacted evidence record.

15. Knowledge check

Bravo becomes allowed after a waiver. Has its risk evidence been remediated?

Why is Delta not waived in the checkpoint?

What Nexus state would be created if an allowed component were actually cached from a proxy?

What is the current configuration model for Firewall on Nexus 3.95.x?

A manager asks you to make the waiver never expire “so this never blocks us again.” What should you do?

16. Chapter summary and bridge to Chapter 23

Chapter 22 added a policy-governance layer to the production artifact-repository model: Nexus stores and serves artifacts; IQ/Firewall supplies component intelligence and procurement policy; quarantine is an observable policy disposition; waivers are scoped risk decisions with owners and expiry; and availability/security behavior must be documented rather than bypassed. Chapter 23 now broadens the evidence model to SBOMs, provenance, vulnerability governance, signatures/checksums, and supply-chain risk—showing which facts are immutable, which evolve, and which controls can be bypassed through alternate routes.

Official references and version notes

Keep the academy open

Support free, practical DevOps education.

Every lesson is designed to remain readable in a browser, downloadable from GitHub, and usable without a paid learning platform. Contributions help expand and maintain the curriculum.

Ethereum / ERC-20
0x716c4Ab160C4B66F31a28AE2448BfF68fc3a2ef0 Send only Ethereum/ERC-20 compatible assets to this address.