Chapter 34Lesson 01~180 minutes

Capstone: Operate a Governed Production SonarQube Quality Platform: Core Concepts and Mental Model

Integrate the full SonarQube evidence chain into one governed, recoverable, edition-aware production operating model before changing any control.

CapstoneOperating modelEvidence chainRecoveryEdition-aware

Learning objectives

  • Connect source/IDE/CI/scanner/Compute Engine / database / search / policy / security / operations / governance into one causal production model.
  • Inventory exact revision, effective analysis inputs, asynchronous task state, persistent result, credentials, infrastructure and governance state before mutation.
  • Separate scan success, upload, Compute Engine success, analysis completion, gate status, CI result and provider decoration as independent evidence points.
  • Explain which controls are mandatory in Community Build and which commercial capabilities are optional extensions.
  • Build a read-only production-readiness inspection sequence that can be repeated by another operator.

1. The capstone problem: a platform is more than a scanner

Earlier chapters isolated one concern at a time: analysis inputs, quality policy, security, CI integration, identity, APIs, deployment, backup, upgrades, clustering, performance, troubleshooting and governance. Production operation fails when those correct local practices are not joined into one operating model. A scanner can exit successfully while Compute Engine fails later; a gate can pass while a CI job reports stale data; a backup file can exist while nobody has proved it restores; a dashboard can look healthy while its exception register has expired controls.

The capstone therefore asks a stricter question: Can another authorized operator independently prove what source was analyzed, with which effective inputs, what asynchronous work completed, which policy evaluated the result, what external system consumed it, and how the platform can be recovered or upgraded? If any link is implicit, the platform is not yet governed production infrastructure.

Capstone rule

Do not begin by changing a gate, adding a plugin, increasing permissions, restarting a service or buying an edition. Begin with a read-only inventory and an evidence map. The smallest reversible change comes only after the owning layer is known.

2. Mental model: evidence-bearing arrows, not a feature checklist

The operating chain starts with developer feedback, but the durable decision is server-side. Source and build/test evidence enter the scanner. The scanner discovers/indexes files, runs analyzers/sensors and produces an analysis report. Upload hands the report to SonarQube; Compute Engine processes it asynchronously; the database and embedded search support persistent project results and retrieval. Profiles, New Code and quality gates convert technical observations into governed policy outcomes. CI/provider/IDE/API surfaces consume those outcomes. Operations must then keep the system observable, recoverable, upgradeable and sized. Governance closes the loop by recording ownership, exceptions, evidence and review decisions.

Capstone causality
flowchart TD A["Developer / IDE feedback"] --> B["SCM revision + CI build/test"] B --> C["Scanner: scope + analyzers + report"] C --> D["Upload + Compute Engine task"] D --> E["Database + embedded search"] E --> F["Issues + measures + New Code + gate"] F --> G["CI / API / DevOps decoration"] G --> H["Logs + backup + upgrade + capacity"] H --> I["Governance + audit + exceptions"] I --> B

Every arrow is evidence-bearing. B → C must preserve commit identity and effective parameters. C → D must preserve report-task.txt and the Compute Engine task identifier. D → E is where asynchronous processing becomes durable server state. E → F depends on profile/gate/New Code configuration, not just scanner output. F → G crosses a trust boundary into CI/providers. G → H becomes an operational responsibility. H → I creates the auditable record used to decide whether the system remains fit for production.

3. Define state and ownership before changing it

A production operating model becomes debuggable when each fact has exactly one owning layer and a named evidence source. The table below is deliberately redundant with prior chapters because capstone work depends on refusing cross-layer shortcuts.

State Example evidence Owner / wrong inference
Source/revision git rev-parse HEAD, clean/dirty status, build manifest SCM/CI owns revision checkout. A Sonar project key is not a revision.
Scanner/runtime sonar-scanner --version, scanner log, JRE provisioning record Scanner environment. Server Java version does not prove scanner Java version.
Analysis parameters repository properties + CI env + command invocation + scanner effective log Scanner/config sources. Do not infer scope from repository layout.
Compute Engine .scannerwork/report-task.txt, task API/UI status, ce.log Server asynchronous processing. Upload success is not CE success.
Persistent application state supported database backup, project measures/issues/settings Database-backed application state. Search indexes are operational/rebuildable state, not the canonical backup.
Search/JVM/host es.log, system info, CPU/RAM/disk/GC evidence Operations layer. Do not edit embedded search internals as routine repair.
Policy profile assignment, gate assignment/status, New Code definition Project/instance governance. Gate pass is not scanner success.
Credential/trust token owner/type/expiry, permission response, TLS chain Identity/network layer. Never solve uncertainty with admin tokens or TLS disablement.
CI/provider/IDE job artifact, commit SHA, status/decoration/Connected Mode evidence External system. Provider decoration can fail after server analysis succeeds.
Governance owner, rationale, exception expiry, change ticket, review decision Organization. A product report does not supply business rationale by itself.
State manifest

Create evidence/00-manifest.md before the lab. Record: generation date, operator, platform edition/version, Docker image digest, database image digest, scanner version, Java mode, project key, commit SHA, active profile/gate/New Code policy, token owner/purpose (never token value), and the paths where first-failure artifacts will be stored.

4. Read-only production-readiness inspection first

Perform these checks before any mutation. They are read-only except for creation of local evidence files.

mkdir -p evidence/{scanner,server,api,ci,backup,governance}
date -u +%FT%TZ | tee evidence/00-generated-at.txt
git rev-parse HEAD | tee evidence/00-revision.txt
git status --porcelain=v1 | tee evidence/00-worktree-status.txt
sonar-scanner --version | tee evidence/00-scanner-version.txt

docker image inspect sonarqube:26.9.0.129388-community \
  --format '{{index .RepoDigests 0}}' | tee evidence/00-sonarqube-image.txt

docker compose ps | tee evidence/server/compose-ps.before.txt
docker compose logs --no-color --tail=250 sonar > evidence/server/sonar.before.log

# Read-only API status. Authentication requirements vary by endpoint/version.
curl -fsS http://localhost:9000/api/system/status \
  | tee evidence/api/system-status.before.json
Authentication note

For authenticated Web API calls, place a fake/local lab token in the SONAR_TOKEN environment variable and use Authorization: Bearer .... Do not print the token, commit it, or place it in a URL. Current documentation notes that Web API V2 is gradually replacing existing endpoints, so validate every endpoint in the built-in API documentation of the exact instance you operate.

For a project that already exists, inspect rather than assume the current policy and result. Capture the project measures you care about, current quality-gate status, latest analysis timestamp/task evidence, permission outcome and CI artifact that names the same revision. If an endpoint has moved in your release, record the replacement instead of silently switching to an undocumented internal route.

5. The capstone evidence chain

“SonarQube passed” is too lossy for production. Replace it with a chain of independently testable checkpoints.

Checkpoint Question to prove Minimum artifact
Revision Exactly what code did the build and scanner see? Commit SHA + worktree/CI checkout evidence
Build/test Which test/coverage/external reports existed before scan? Producer report + producer command/version
Indexing What did the scanner actually include/exclude? Scanner log with indexed-file and report-import evidence
Upload Was an analysis report accepted? Scanner success line + report-task.txt
CE Did background processing finish successfully? Task ID/status + first-failure CE evidence if not
Result Which issues/measures/New Code population became durable? API/UI export tied to analysis/revision
Gate Which gate and conditions evaluated that result? Gate assignment + status/conditions
CI/provider/IDE What downstream signal used the result? Job/status/decoration/Connected Mode artifact
Operations Could the platform be restored/upgraded/sized? Restore proof + update plan + capacity baseline
Governance Who owns deviations and residual risks? Owner/rationale/expiry/review record
Independent verification

A useful control is reproducible only if another operator can start from the same revision and effective inputs, locate the same task/result, identify the same policy context and understand which external system owns the final delivery signal.

6. Edition and product boundaries in the operating model

The capstone remains valuable even if your organization never licenses a commercial edition. The core control model—source identity, scanner evidence, asynchronous processing, policy, permissions, API automation, backup discipline, upgrade planning and governance—exists independently of paid aggregation or HA capabilities.

Surface Capstone role Ownership / edition boundary
Community Build Mandatory free/local analysis, profiles, gates, New Code, issues/measures, permissions, API and operations practice. Self-managed free product; no commercial feature may be required to complete the capstone.
Commercial SonarQube Server Optional branch/PR, advanced security, Applications/Portfolios, enterprise reporting/identity and higher-scale features. Developer/Enterprise features are edition-dependent; verify current license before design.
Data Center Edition Optional HA/horizontal-scaling architecture exercise. Licensed multi-node topology; never simulate it by calling independent Community nodes a cluster.
SonarQube Cloud Hosted product comparison only. Different operating model: do not reuse Server backup/database/cluster assumptions.
SonarQube for IDE Free developer-feedback surface and Connected Mode exercise. Developer feedback is not the authoritative CI/server quality gate.
No-paid-path invariant

If an optional commercial feature improves convenience—portfolio roll-up, enterprise report, branch/PR analysis, enterprise identity or Data Center HA—the lesson must still show how to prove the underlying control locally. The simulation is documented as a simulation; it is never mislabeled as the licensed feature.

7. Production control objectives

The capstone outcome is not a specific topology. It is a set of control objectives that remain provable when topology, edition or CI provider changes.

Control objective Good evidence Anti-pattern
Reproducible analysis Revision + effective parameters + indexed-file/report evidence + task ID “The scanner ran on main.”
Least privilege Named token owner/purpose/expiry + permission test One administrator token in every CI job
Policy integrity Versioned desired standard + assignment snapshot + bounded exception record Lowering thresholds to make the build green
Recoverability Database backup + isolated restore/reindex proof + measured result A backup file that has never been restored
Upgradeability Supported-path matrix, plugin/scanner/database check, rollback/recovery plan Arbitrary downgrade after failed upgrade
Capacity Measured scanner/CE/DB/search/host baseline and headroom Copying a reference architecture as a guarantee
Incident response Preserved first-failure packet + one-hypothesis correction + same-input rerun Restart/delete caches before collecting evidence
Governance Owners, exception expiry, trend/remediation review, residual risks Ranking developers by issue counts

8. Knowledge check

The scanner exits 0 and writes report-task.txt. What is proven?

Why is a copied search directory not the primary durable backup?

A team requests Data Center Edition because one analysis is slow. What should happen first?

Why must an exception have an owner and expiry even if SonarQube records an issue status?

Which artifact best links scanner and server evidence?

9. Summary and bridge

You now have the capstone operating model: every control is tied to an owning layer and independently verifiable evidence. Lesson 2 turns that model into a disposable end-to-end platform and exercises analysis, gate enforcement, API automation, developer feedback, backup evidence and one incident/recovery cycle.

Next lesson

Capstone: Operate a Governed Production SonarQube Quality Platform: Guided Hands-On Workflow

Continue to the next lesson to build on this lesson’s evidence, workflow, and operational practices.

Official references and version notes

Further reading

Verify version-sensitive behavior against primary documentation before using these patterns outside the disposable lab.

Version and compatibility note

SonarQube product names, editions, release trains, scanner runtimes, APIs, authentication options, and platform prerequisites can change independently. Re-check the linked SonarSource primary documentation for the exact target release before applying version-sensitive commands or operational guidance outside the disposable course environment.

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
0x716c4Ab160C4B66F31a28AE2448BfF68fc3a2ef0Send only Ethereum/ERC-20 compatible assets to this address.