
From GPU SKU to Base Image: Mapping Where Export Controls Reach Your AI Build Pipeline
The GPU is the part everyone audits. The base image is the part everyone ships. This post maps how a new round of US export controls on advanced chips propagates from GPU SKUs and foundry process nodes into the base images, CI runners, and artifacts a software team actually builds — and shows how to inventory that chain and put a fail-closed gate in front of it.
On 19 and 20 November 2026, Nikkei Asia, Businesskorea, BusinessToday Malaysia, and BigGo Finance all ran reports on new US chip export rules taking effect, with TSMC tightening restrictions on Chinese AI customers. The BigGo Finance headline from 19 November is the most specific: TSMC reportedly halted orders from Chinese AI customers for 16nm and below. Nikkei Asia, on 20 November, reported that the chip supply chain is warning of broader disruption.
If you build AI-powered software, none of those headlines name anything you directly control. You don't buy wafers. You probably don't buy GPUs either; your cloud provider does. The instinct is to file this under "hardware people problems" and get back to the sprint.
That instinct is wrong, and not for the obvious reason. The real export surface for a team running an AI build pipeline is the image lineage in your Dockerfile, the region your CI runner resolves to, and the artifact you push at the end. Three things you can inventory this week with the tooling you already have.
The position is blunt: if you can't name the digest of your CUDA base image and the region your runner ran in, you can't answer the question the new rules are asking — and you won't know whether they apply to you until someone else tells you.
On this page
What the November 2026 export-control reports confirm — and what they leave open
Confirmed claims in the 19–20 November reporting
The reporting is consistent on four points, and each is attributable:
| Claim | Source | Date |
|---|---|---|
| New US chip export rules have taken effect | BigGo Finance; Businesskorea | 19–20 Nov 2026 |
| TSMC is tightening restrictions on Chinese AI customers | BusinessToday Malaysia | 20 Nov 2026 |
| TSMC halted orders from Chinese AI customers for 16nm and below | BigGo Finance | 19 Nov 2026 |
| The chip supply chain is warning of broader disruption | Nikkei Asia | 20 Nov 2026 |
That is the extent of what the aggregated reporting establishes. Note what is not in that table: no rule citation, no ECCN, no named customer, no named SKU, no effective-date detail beyond "took effect."
Five unconfirmed questions that decide whether this reaches your pipeline
Each is load-bearing — the answer changes what you do.
- Which specific SKUs and part numbers are covered. The reports describe a process-node threshold, not a parts list. No named accelerator appears in the source material.
- Which customers. "Chinese AI customers" is a category, not a company list. Whether it covers design houses, cloud tenants, or OEMs isn't stated.
- Order intake vs. shipment. A halt on new orders is a different event from a halt on delivery of already-placed orders. The BigGo headline says "halts orders," which most plausibly reads as intake, but the reporting doesn't resolve it.
- Commercial decision or regulatory response. BusinessToday Malaysia frames it as "following new US export rules," implying a response. Whether TSMC is acting under a licence condition, a direct instruction, or its own conservative reading of the rule isn't established. This matters: a voluntary tightening can be walked back; a licence condition cannot.
- Whether "16nm and below" is a process-node threshold or a product-category proxy. Foundries filter orders by node because that's how the fab is organised. Regulators filter by part number. Those aren't the same filter, and conflating them produces bad predictions.
I'm treating all five as unconfirmed. The rest of this post is written so the engineering work holds regardless of how they resolve — which is the point of inventorying your own lineage instead of reasoning about theirs.
Why "16nm and below" is a much wider net than "AI accelerator"
This is the part that should get a build engineer's attention.
16nm-class and below covers:
- Networking silicon. SmartNICs, DPUs, switch ASICs, and the PHY/PCS blocks around them.
- Baseboard management controllers and BMC-adjacent SoCs. The chip running out-of-band management on the very servers your CI runners sit on.
- Image signal processors and edge SoCs in cameras, robots, and inspection hardware.
- Older inference parts taped out on 16nm/12nm when that was the leading edge, many still shipping into edge deployments and lab rigs.
Inference: a node-threshold restriction is a coarse filter that catches a lot of non-AI silicon. If a foundry applies an order filter at 16nm, the affected set is much larger than the set of accelerator SKUs, and some of the disruption Nikkei reports would show up as shortages in networking and management silicon rather than in GPUs. That fits the "broader disruption" framing, but the reporting doesn't confirm the mechanism. Treat it as the most likely reading, not a fact.
The Hannibal note: what would confirm each open question
Call it the Hannibal note: the risk that arrives from a direction nobody was watching. For each open item above, here's what would confirm it and what changes if it resolves the other way.
| Open item | What would confirm it | If it resolves the other way |
|---|---|---|
| SKU coverage | Published rule text with part numbers, or a TSMC customer notice naming families | If it stays node-based, networking and BMC silicon are in scope too — your non-GPU infrastructure gets the same scrutiny |
| Customer scope | Named-entity list in the rule, or customer confirmations | If it covers design houses, IP licensing and EDA flows become the boundary instead of fabs |
| Intake vs delivery | TSMC statement, or customer reports of delayed deliveries | If delivery is halted, existing capacity contracts become a legal question, not just a supply one |
| Voluntary vs compelled | Rule text referencing licence conditions, or TSMC's own framing | If voluntary, timeline risk goes down and reversal risk goes up |
| Node as proxy | Rule text describing device categories rather than process geometry | If it is a product-category proxy, your ECCN research has to happen before your capacity planning |
The engineering consequence: build your inventory so a change in any of these rows is a policy-file edit, not a rewrite. That's the whole design goal of the gate below.
The six-layer dependency chain from a GPU SKU to your Dockerfile
Six layers sit between a process node and the container you push. Each has a different owner, a different kind of evidence, and a different answer to "what crosses a border."
Layer 0 — the fab process node behind the SKU
The node is the control surface, not the brand. A 7nm part from one vendor and a 7nm part from another are the same regulatory object in a node-threshold regime, regardless of what the box says. "We use vendor X" is not a compliance answer.
You can't verify the node from inside your pipeline. You can only record what the vendor claims and cite it. That's a documentation task, not an engineering one — but it belongs in the same inventory, because every other layer is downstream of it.
Layer 1 — the SKU and its export classification
In the US system, export classification lives in the Export Administration Regulations' Commerce Control List, keyed by Export Control Classification Number (ECCN). The ECCN is a five-character alphanumeric code that determines whether a part needs a licence for a given destination. Advanced-computing controls sit in Category 3 (electronics) and Category 4 (computers) of the CCL.
I'm deliberately not assigning an ECCN to any named part. Classification is a legal determination made against a specific part's specifications, and getting it wrong in either direction is expensive. The engineering point is narrower: an ECCN is an attribute of the part, and it should appear in your inventory next to the SKU, sourced from the vendor's own classification statement rather than inferred from a spec sheet.
Layer 2 — the cloud GPU instance type and its physical region
An instance type is a provider-specific label. p5.48xlarge, a3-highgpu-8g, ND96asr_v4 — three names for machines that may or may not contain the same silicon. What matters for a control is the physical region the workload resolves to, because that determines jurisdiction.
Region is also the layer most likely to drift without anyone noticing, because CI runners are often scheduled by a hosted runner pool you didn't choose per-job.
Layer 3 — the driver and CUDA base image lineage
This is the layer software teams own, and the one almost nobody inventories. An nvidia/cuda image is not a thin Ubuntu wrapper. Depending on the tag, it carries:
- the CUDA runtime (
libcudart), cuBLAS, cuFFT, cuRAND, cuSPARSE, cuSOLVER, cuDNN, and NCCL redistributables; - driver stub libraries (
libcuda.sostub) for build-time linking; - in
develtags, the full compiler toolchain (nvcc), headers, and static libraries.
Redistributable binaries are still technology. Arriving as a .so in a layer rather than a card in a box is a packaging detail, not a category change.
Layer 4 — the CI runner and its build cache
Hosted, self-hosted, or GPU-enabled self-hosted. Three sub-questions per runner:
- Where does it physically execute?
- What GPU, if any, is attached, and what compute capability does it report?
- Where does its build cache live, and who can read it?
The third is the one people miss. A self-hosted runner with a persistent buildx cache on a shared volume is a redistribution channel.
Layer 5 — the build artifact, its SBOM, and its provenance
The final image is where all five previous layers land. If you attach an SBOM and a provenance attestation, the artifact carries its own lineage: which base digest it came from, what was in it, what build produced it. If you don't, that knowledge lives in a wiki page that was last accurate in Q1.
Layer-by-layer comparison: what crosses a border, and what you can verify
| Layer | What crosses a border | What a control can plausibly touch | What you can verify yourself |
|---|---|---|---|
| 0 — process node | Physical wafers, reticles | Fab order intake, licence conditions | Nothing directly; record vendor claim + citation |
| 1 — SKU / ECCN | Physical parts, documentation | Sale, resale, re-export, technical data | Vendor classification statement; do not self-assign |
| 2 — instance + region | Compute service delivery | Provider terms, regional availability | Instance metadata endpoint, provider region docs |
| 3 — driver / CUDA image | Redistributable binaries in layers | Registry access, image pull policy | Manifest digest, config blob, layer contents |
| 4 — CI runner | Build execution, cache contents | Where jobs run, who reads the cache | Runner labels, metadata service, cache config |
| 5 — artifact + SBOM + provenance | The image and its attestations | Artifact distribution | docker buildx imagetools inspect, attestation verify |
The right-hand column is the only one you fully own. Everything to its left is someone else's determination. That asymmetry should drive your priorities.
Why base images are the underrated export surface
The deemed-export question: is a container layer a release?
Here's an engineering argument, not a legal conclusion.
A CUDA base image is US-origin technology. Pulling it from a public registry and pushing it to an internal registry is a copy. Serving that copy to a person in a restricted jurisdiction is a different kind of event from shipping a GPU: no hardware, no customs, no invoice, and it happens at the speed of a docker pull.
US export rules include the concept of a deemed export: releasing controlled technology to a foreign national inside the US can be treated as an export to that person's country. Whether a specific redistributable container layer constitutes controlled technology, and whether a given access pattern constitutes a release, are legal questions I can't answer and am not trying to.
What I can say as an engineer is this: the control surface exists, the access log exists, and most teams have no idea who can pull from their internal registry. That's a fixable problem independent of how the legal question resolves. Talk to counsel about the interpretation; fix the access review this week either way.
What is actually inside an nvidia/cuda image
The runtime versus devel split is not cosmetic.
| Tag flavour | Contents | Relative surface |
|---|---|---|
base | Minimal CUDA runtime libs | Smallest |
runtime | Full runtime libs (cuBLAS, cuDNN, NCCL depending on tag) | Moderate |
devel | Runtime + nvcc, headers, static libs, dev tooling | Largest |
cudnn-devel etc. | Adds framework-specific redistributables | Largest |
Practical rule: build multi-stage, run on runtime. Compiling in devel and copying the resulting binary into a runtime final stage removes the compiler toolchain and headers from the shipped artifact. That's a size win and a surface win, for about six lines of Dockerfile.
FROM nvidia/cuda:12.4.1-devel-ubuntu22.04 AS build
WORKDIR /src
COPY . .
RUN make -j"$(nproc)"
FROM nvidia/cuda:12.4.1-runtime-ubuntu22.04
COPY --from=build /src/bin/trainer /usr/local/bin/trainer
ENTRYPOINT ["/usr/local/bin/trainer"]
Pin both stages to digests, not tags. More on that below.
Mirrors, forks, and "internal" registries
A copied layer is never a neutral copy. Three things change when you mirror a base image:
- The digest changes if you rebuild it. Re-tagging preserves the digest; rebuilding with a different base or different build args produces a new one. If your internal "mirror" is a rebuild, its lineage ends at the rebuild.
- Provenance ends at the copy unless you carry it forward. A mirror without an attestation is an image of unknown origin.
- Access control becomes yours. Public Docker Hub has its own terms. Your internal registry has whatever your team configured, which is often "all engineers, read and write."
Digest pinning is what makes this auditable. A tag is a mutable pointer: nvidia/cuda:12.4.1-runtime-ubuntu22.04 today and next month can resolve to different layer sets under the same name. A digest is content-addressed. If your SBOM says the base was sha256:abc…, you can prove which bytes you built from, and re-resolve that digest to a manifest to see what it contained.
## mutable tag — lineage changes without your knowledge
FROM nvidia/cuda:12.4.1-runtime-ubuntu22.04
## content-addressed — lineage is a fact you can re-verify
FROM nvidia/cuda@sha256:0000000000000000000000000000000000000000000000000000000000000000
(The digest above is a placeholder. Resolve the real one with docker buildx imagetools inspect nvidia/cuda:12.4.1-runtime-ubuntu22.04. I'm not printing a digest I haven't resolved, because a wrong digest in a blog post becomes a wrong digest in someone's Dockerfile.)
Building a supply-chain inventory you can query
Three artifacts: image lineage, runtime versions, runner context. All three should be machine-generated and committed or uploaded, not typed by hand.
Enumerate every image and resolve its base lineage from the registry manifest
The Docker Registry v2 API lets you walk from a tag to a manifest to a config blob without pulling layers. That's fast and it works in CI. The distribution spec covers the endpoints; OCI image manifests follow the OCI image spec.
const REGISTRY = process.env.REGISTRY ?? "https://registry-1.docker.io";
const REPO = process.env.REPO ?? "nvidia/cuda";
const TAG = process.env.TAG ?? "12.4.1-runtime-ubuntu22.04";
const PLATFORM = process.env.PLATFORM ?? "linux/amd64";
const ACCEPT = [
"application/vnd.oci.image.index.v1+json",
"application/vnd.docker.distribution.manifest.list.v2+json",
"application/vnd.oci.image.manifest.v1+json",
"application/vnd.docker.distribution.manifest.v2+json",
].join(", ");
async function tokenFor(repo) {
const url = `https://auth.docker.io/token?service=registry.docker.io&scope=repository:${repo}:pull`;
const res = await fetch(url);
if (!res.ok) throw new Error(`auth ${res.status}`);
return (await res.json()).token;
}
async function getJson(path, token) {
const res = await fetch(`${REGISTRY}/v2/${REPO}/${path}`, {
headers: { accept: ACCEPT, authorization: `Bearer ${token}` },
});
if (!res.ok) throw new Error(`${path} -> ${res.status}`);
const digest = res.headers.get("docker-content-digest");
return { body: await res.json(), digest };
}
const token = await tokenFor(REPO);
let { body, digest } = await getJson(`manifests/${TAG}`, token);
// Multi-arch index: pick the platform we actually build for.
if (body.manifests) {
const [os, arch] = PLATFORM.split("/");
const entry = body.manifests.find(
(m) => m.platform?.os === os && m.platform?.architecture === arch
);
if (!entry) throw new Error(`no manifest for ${PLATFORM}`);
({ body, digest } = await getJson(`manifests/${entry.digest}`, token));
}
const { body: config } = await getJson(`blobs/${body.config.digest}`, token);
const env = Object.fromEntries(
(config.config?.Env ?? [])
.map((kv) => kv.split("="))
.filter(([k]) => k)
);
const historyCmds = (config.history ?? []).map((h) => h.created_by ?? "");
const cudaEnvs = Object.entries(env).filter(([k]) =>
/CUDA|CUDNN|NCCL|NVIDIA/i.test(k)
);
const baseLabels = Object.fromEntries(
Object.entries(config.config?.Labels ?? {}).filter(([k]) =>
k.startsWith("org.opencontainers.image.")
)
);
console.log(
JSON.stringify(
{
repo: REPO,
tag: TAG,
platform: PLATFORM,
resolvedDigest: digest,
architecture: body.config?.platform,
cudaEnv: Object.fromEntries(cudaEnvs),
ociLabels: baseLabels,
compilerStage: historyCmds.find((c) => /nvcc|devel/i.test(c)) ?? null,
historyLength: historyCmds.length,
},
null,
2
)
);Run it:
REPO=nvidia/cuda TAG=12.4.1-runtime-ubuntu22.04 node scripts/resolve-base-lineage.mjs
The resolvedDigest field is the value you paste into your Dockerfile. Everything else is documentation that goes into the SBOM.
Extract the CUDA, driver, cuDNN, and NCCL versions from a built image
The manifest gives you lineage. It doesn't give you what the linker actually sees at runtime. For that, run the image on a GPU host:
docker run --rm --gpus all nvidia/cuda:12.4.1-runtime-ubuntu22.04 bash -lc '
nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv,noheader
nvidia-smi --query-gpu=compute_cap --format=csv,noheader 2>/dev/null \
|| echo "compute_cap: query unsupported by this driver"
(command -v nvcc >/dev/null && nvcc --version | tail -n1) \
|| echo "nvcc: absent (expected on runtime tags)"
ldconfig -p | grep -E "libcudart|libcublas|libcudnn|libnccl" | sort -u
'
Example output shape — illustrative, not a transcript from your host; versions and driver strings differ per environment:
NVIDIA H100 80GB HBM3, 550.xx.xx, 81920 MiB
9.0
nvcc: absent (expected on runtime tags)
libcudart.so.12 (libc6,x86-64) => /usr/local/cuda/lib64/libcudart.so.12
libcublas.so.12 (libc6,x86-64) => /usr/local/cuda/lib64/libcublas.so.12
libcudnn.so.9 (libc6,x86-64) => /usr/local/cuda/lib64/libcudnn.so.9
The compute_cap query is version-dependent. If your driver doesn't support it, read the capability from the device name and the vendor's compute-capability table instead, and record which method you used. That distinction matters when the record gets audited later.
Record the runner's GPU model, compute capability, and instance type
From inside the runner, query the instance metadata service. AWS IMDSv2 requires a token:
TOKEN=$(curl -sX PUT "http://169.254.169.254/latest/api/token" \
-H "X-aws-ec2-metadata-token-ttl-seconds: 60")
echo "instance-type: $(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/instance-type)"
echo "region: $(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/placement/region)"
echo "az: $(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/placement/availability-zone)"
On GCP the equivalent is:
curl -s -H "Metadata-Flavor: Google" \
http://metadata.google.internal/computeMetadata/v1/instance/machine-type
curl -s -H "Metadata-Flavor: Google" \
http://metadata.google.internal/computeMetadata/v1/instance/zone
Record all of it into one file per build. The artifact then carries hardware context, so a later question about which silicon produced a given binary has a written answer.
Inventory output shape: one JSON record per build
{
"image": "ghcr.io/acme/trainer:1.4.0",
"base": {
"repo": "nvidia/cuda",
"tag": "12.4.1-runtime-ubuntu22.04",
"resolvedDigest": "sha256:<resolved-at-build-time>",
"cudaEnv": { "CUDA_VERSION": "12.4.1", "NVIDIA_REQUIRE_CUDA": "cuda>=12.4" }
},
"runtime": {
"gpu": "NVIDIA H100 80GB HBM3",
"computeCapability": "9.0",
"driver": "<from nvidia-smi>",
"libs": ["libcudart.so.12", "libcublas.so.12", "libcudnn.so.9"]
},
"runner": {
"provider": "aws",
"instanceType": "<from IMDS>",
"region": "<from IMDS>",
"availabilityZone": "<from IMDS>"
},
"sbom": "sbom.spdx.json",
"provenance": "ghcr.io/acme/trainer@sha256:<artifact-digest>.att"
}
Illustrative shape only. The version strings are placeholders; your values will differ, and they should be generated, never typed.
Turning the inventory into a CI gate
An inventory nobody reads is a compliance decoration. The gate is what turns it into a control.
A pre-build policy check in Node
Four rules, all fail-closed:
- Base image must be digest-pinned.
- Base digest must not be on the deny list.
- SBOM must exist for the artifact.
- Runner region must be present and in the allowed set.
import { readFile } from "node:fs/promises";
const lineagePath = process.argv[2] ?? "lineage.json";
const lineage = JSON.parse(await readFile(lineagePath, "utf8"));
const policy = {
denyDigests: new Set(
(process.env.DENY_DIGESTS ?? "").split(",").map((s) => s.trim()).filter(Boolean)
),
allowedRegions: new Set(
(process.env.ALLOWED_REGIONS ?? "us-east-1,eu-central-1")
.split(",").map((s) => s.trim()).filter(Boolean)
),
requireSbom: true,
requireRunnerRegion: true,
};
const failures = [];
const warnings = [];
const evidence = [];
const ref = lineage.base?.tag ?? "";
const digest = lineage.base?.resolvedDigest ?? "";
// 1. digest pinned?
if (!/^sha256:[a-f0-9]{64}$/.test(digest)) {
failures.push(`base digest unresolved or malformed: "${digest}"`);
} else {
evidence.push(`base digest resolved: ${digest}`);
}
// 2. tag-only references are treated as unpinned even if the digest resolved
if (ref && !ref.includes("@sha256:")) {
failures.push(
`base reference uses mutable tag "${ref}" — pin as repo@sha256:…`
);
}
// 3. deny list
if (policy.denyDigests.has(digest)) {
failures.push(`base digest is on the restricted list: ${digest}`);
} else if (policy.denyDigests.size === 0) {
warnings.push("DENY_DIGESTS is empty — restricted-list check is a no-op");
}
// 4. SBOM
if (policy.requireSbom && !lineage.sbom) {
failures.push("no SBOM recorded for this artifact");
} else if (lineage.sbom) {
evidence.push(`sbom attached: ${lineage.sbom}`);
}
// 5. runner region
const region = lineage.runner?.region ?? process.env.RUNNER_REGION ?? "";
if (policy.requireRunnerRegion && !region) {
failures.push("runner region not tagged (lineage.runner.region and RUNNER_REGION both empty)");
} else if (region && !policy.allowedRegions.has(region)) {
failures.push(`runner region "${region}" is not in the allowed set`);
} else if (region) {
evidence.push(`runner region: ${region}`);
}
for (const w of warnings) console.warn(`[gate] WARN ${w}`);
for (const e of evidence) console.log(`[gate] ok ${e}`);
if (failures.length) {
for (const f of failures) console.error(`[gate] FAIL ${f}`);
console.error(`[gate] decision: BLOCK (${failures.length} failures)`);
process.exit(1);
}
console.log("[gate] decision: ALLOW");
The "tag-only reference is a failure even when the digest resolved" rule is deliberate. A resolved digest tells you what the tag pointed at when you resolved it. It doesn't tell you what the Dockerfile will pull next week. Treating those as the same thing is the single most common mistake in this space.
Wiring the gate into GitHub Actions
name: build
on: push
jobs:
gate:
runs-on: ubuntu-24.04
outputs:
base-digest: ${{ steps.lineage.outputs.digest }}
steps:
- uses: actions/checkout@v4
- name: Resolve base lineage
id: lineage
env:
REPO: nvidia/cuda
TAG: 12.4.1-runtime-ubuntu22.04
run: |
node scripts/resolve-base-lineage.mjs | tee lineage.json
node -e "const l=require('./lineage.json');console.log('digest='+l.resolvedDigest)" >> "$GITHUB_OUTPUT"
- name: Policy gate (fail closed)
env:
DENY_DIGESTS: ${{ vars.DENY_DIGESTS }}
ALLOWED_REGIONS: us-east-1,eu-central-1
RUNNER_REGION: ${{ vars.RUNNER_REGION }}
run: node scripts/policy-gate.mjs lineage.json
build:
needs: gate
runs-on: ubuntu-24.04
permissions:
contents: read
packages: write
id-token: write
attestations: write
steps:
- uses: actions/checkout@v4
- uses: docker/build-push-action@v6
id: build
with:
push: true
provenance: mode=max
sbom: true
tags: ghcr.io/${{ github.repository }}/trainer:${{ github.sha }}
- uses: actions/attest-build-provenance@v1
with:
subject-name: ghcr.io/${{ github.repository }}/trainer
subject-digest: ${{ steps.build.outputs.digest }}
push-to-registry: true
A failing run looks like this. Captured as text, because that's the evidence that matters:
Run node scripts/policy-gate.mjs lineage.json
[gate] ok base digest resolved: sha256:<resolved>
[gate] WARN DENY_DIGESTS is empty — restricted-list check is a no-op
[gate] ok sbom attached: sbom.spdx.json
[gate] FAIL base reference uses mutable tag "12.4.1-runtime-ubuntu22.04" — pin as repo@sha256:…
[gate] FAIL runner region not tagged (lineage.runner.region and RUNNER_REGION both empty)
[gate] decision: BLOCK (2 failures)
Error: Process completed with exit code 1.
Two failures, both actionable in under a minute. That's the right ratio. A gate that produces eleven warnings and no blocks is theatre.
Attaching provenance so lineage travels with the artifact
Two mechanisms, complementary:
- SBOM (
sbom: trueinbuild-push-action) records what is inside the image. SPDX and CycloneDX are the two formats worth supporting; both are tool-readable. - Provenance attestation (
provenance: mode=max) records how it was built: build definition, base digests, builder identity, timestamps. The SLSA provenance spec is the reference model.
The combination is what makes the inventory queryable from the artifact side. docker buildx imagetools inspect ghcr.io/acme/trainer@sha256:… shows the attestation manifests, and the base digest appears inside the provenance. A later question about which CUDA image produced a given binary resolves without consulting a wiki.
Three rules that keep the gate honest
- Fail closed on unknown lineage. An unresolvable digest is a block, not a warning. If the registry is down, you don't know what you're building from, and "we couldn't check" must not equal "we checked and it was fine."
- Warn on known-but-stale. A pinned digest that's N months old is a real risk, but not the same risk. Separate the channel so the signal stays readable.
- Log the evidence that produced the decision. Print the resolved digest, the region, the SBOM path, and the deny-list size on every run — pass or fail. When someone asks six months later why a build was allowed, the log is the answer, and it shouldn't require re-running anything.
One warning worth designing for explicitly: an empty deny list means the restricted-party check passes trivially. That's worse than no check, because it looks green. The gate above emits a warning for exactly this reason; make it a hard failure if your organisation has committed to maintaining the list.
Cloud region and capacity risk in practice
The GPU instance-type mapping problem
One GPU SKU appears under several instance names across providers, and the mapping drifts. A provider renames a family, adds a size, or retires a generation, and your inventory's instanceType field becomes a historical artifact rather than a current fact.
Keep two fields, not one: instanceType (what the provider called it) and gpuModel (what nvidia-smi reported). The first is a commercial label that will drift; the second is measured. When they disagree, trust the measured value — and the disagreement itself is useful data.
What disruption looks like to a build pipeline
Nikkei Asia describes supply-chain warnings of broader disruption. Translated into pipeline symptoms, that's:
- Longer queue times on GPU-enabled runners, because capacity is allocated away from interruptible workloads.
- More aggressive spot reclamation, which turns a 40-minute training build into a flaky job.
- Instance families quietly disappearing from a region, with the console still listing them in another.
- Longer lead times on replacement parts, which shows up as self-hosted GPU runners staying degraded for weeks.
None of these announce themselves. All are visible in build-duration percentiles if you're recording them — another reason the runner context belongs in the inventory.
Three mitigations that pay for themselves
- Multi-region build targets. If your gate accepts more than one region, a capacity event is a rerun with a different
RUNNER_REGION, not an incident. - Prebuilt CUDA base images in your own registry. Pull the upstream image once, verify the digest, push it to your registry, archive the SBOM. Builds stop depending on an external pull at build time, and your lineage becomes a fact you host.
- A CPU-only path for the parts of CI that never needed a GPU. Linting, unit tests, SBOM generation, and policy checks all run fine on a standard runner. Moving them off GPU runners reduces contention on the scarce resource and shortens the queue for the jobs that genuinely need silicon.
The third one is usually the biggest win, and it's the one teams skip because the GPU runner "already exists."
Where teams get this wrong: four recurring failures
Treating it as a legal-only problem while the pipeline keeps pulling floating tags
This is the most common failure. Legal reviews the rule, engineering keeps FROM nvidia/cuda:latest. When the rule text changes, legal has to re-read it and engineering has to guess which of forty Dockerfiles are affected.
The fix isn't more legal review. It's making the pipeline's inputs expressible as a list. You can't reason about forty floating tags, but you can review forty digests.
Assuming the provider's compliance posture covers your workload and your artifacts
Your cloud provider's compliance documentation describes their service. It doesn't describe the container you built on top of their instance, nor the cache your self-hosted runner left on a persistent volume, nor the internal registry you pushed to.
The boundary is the artifact, not the infrastructure it ran on. Providers are explicit about this in their shared-responsibility documentation; teams read the compliance page and stop at the first reassuring sentence.
Assuming a mirrored or forked base image inherits no obligations
A mirror is a copy, and a copy is a distribution event. If your internal registry is readable by everyone in the org, you've made the base image available to everyone in the org, regardless of what the original upstream said.
Two concrete fixes: scope registry read access to build service accounts plus a named reviewer group, and record the upstream digest in the mirror's attestation so the lineage is provable rather than asserted.
Repeating vendor framing as fact
Read the difference carefully:
- What a notice states: "orders from Chinese AI customers for 16nm and below have been halted." (BigGo Finance, 19 Nov 2026 — itself a report of a TSMC action, not a TSMC statement.)
- What a summary implies: "AI chips are unavailable." That's a much stronger claim, and the source material doesn't support it.
The gap between those two sentences is where most bad architecture decisions get made. When you write the internal memo, keep the two columns separate. When you write the code, make the policy file the place where the interpretation lives, so that changing it is a one-line diff with a review trail.
A 30-minute audit you can run this week
| # | Check | How | Pass condition |
|---|---|---|---|
| 1 | Image lineage resolved | resolve-base-lineage.mjs on every FROM nvidia/* reference | Every base has a sha256: digest |
| 2 | Digests pinned in Dockerfiles | grep -rn "FROM nvidia/" --include=Dockerfile* | Zero tag-only references |
| 3 | GPU stack versions recorded | nvidia-smi + ldconfig one-liner | Versions in inventory, with method noted |
| 4 | Runner regions tagged | IMDS/GCP metadata query in CI | runner.region non-empty on every build |
| 5 | SBOM present | sbom: true or syft in the build | Artifact has an SPDX or CycloneDX document |
| 6 | Provenance attached | provenance: mode=max + attestation push | Attestation resolvable from the digest |
| 7 | Registry access reviewed | Pull the registry's access list | Read access limited to named principals |
Checks 1 and 2 are a grep and a script. Check 3 is one docker run. Checks 5 and 6 are two lines of workflow YAML. Check 7 is the one that takes a conversation, and it's also the one with the largest unaddressed exposure in most organisations.
That's a realistic half hour if your build already runs in CI, and an afternoon if it doesn't.
What would change the picture: rule signals and repo tripwires
Concrete signals to watch in the rule text
- The published rule text and effective date. Until the actual notice is readable, every downstream claim is a summary of a summary. Watch the Federal Register and the BIS regulations page rather than the reporting about them.
- Any named SKU list. If the rule names parts, the question moves from process geometry to part numbers, and your ECCN field becomes the load-bearing one.
- Order intake versus delivery. If delivery is included, existing capacity contracts become legal exposure, not just an availability problem.
- Whether other foundries follow. A single-foundry restriction is a capacity story. A coordinated one is a supply-chain restructuring story, and the timelines are completely different.
Technical tripwires inside your own repo
You can tell whether the answer matters to you without reading the rule at all:
## Does any build depend on a CUDA base image?
grep -rn "FROM .*nvidia/cuda\|FROM .*nvcr.io" --include=Dockerfile* . | wc -l
## Are those references pinned?
grep -rn "FROM .*nvidia/cuda" --include=Dockerfile* . | grep -v "@sha256:" | wc -l
## Does the build run on a GPU runner, and is the region recorded?
grep -rn "runs-on:.*gpu\|RUNNER_REGION" .github/ | head
## Does an internal registry mirror exist?
grep -rn "registry\|mirror" docker-bake.hcl .github/workflows/*.yml 2>/dev/null | head
If the first number is zero, this is someone else's problem this quarter. If the second number is non-zero, you have unpinned lineage and the question is live whether or not the rule names you. If the third grep returns nothing on region, your gate can't answer the jurisdiction question at all.
Conclusion
The base image is the border crossing most teams never inventory. It has no invoice, no customs declaration, and no serial number — just a FROM line that resolves to whatever the tag points at today.
The reporting from 19–20 November 2026 leaves most of the important questions open: which SKUs, which customers, intake or delivery, voluntary or compelled, node threshold or product proxy. What it doesn't leave open is that the chain from a fab process node to your Dockerfile runs through artifacts you control. Six layers, and the last three are yours.
The cheapest thing you can do about an unclear rule is make your own lineage legible: resolve every base digest, pin it, record the CUDA and driver versions, tag the runner region, attach an SBOM and a provenance attestation, and put a gate in front of the build that fails closed when lineage is unknown. That work is worth doing even if the rule turns out not to name anything you ship, because the same inventory answers the next question — the incident, the audit, the "which binary is in production" ticket at 2am.
Do the grep. Pin the digests. The rule text will catch up.
Further Reading
Primary sources and stable references. Where a specific rule document could not be verified at the time of writing, the stable index page is linked instead and that limitation is noted.
Reporting (the source material for this post)
- BigGo Finance, 19 November 2026 — "New U.S. Chip Rules Take Effect; TSMC Halts Orders from Chinese AI Customers for 16nm and Below": news seed link. This is an aggregator redirect; if it expires, search the publisher's own site for the headline.
- Nikkei Asia, 20 November 2026 — "Chip supply chain warns of broader disruption from new US export controls": news seed link. Aggregator redirect, same caveat.
- Businesskorea, 20 November 2026 — "U.S. Tightens Controls on Chinese Access to AI Chips": news seed link. Aggregator redirect.
- BusinessToday Malaysia, 20 November 2026 — "TSMC Tightens China Chip Restrictions Following New US Export Rules": news seed link. Aggregator redirect.
Regulatory primary sources
- Bureau of Industry and Security — Regulations. The EAR and Commerce Control List live here. The specific rule referenced in the 19–20 November 2026 reporting was not publicly verifiable at the time of writing; check this index and the Federal Register directly rather than relying on summaries.
- Federal Register — Industry and Security Bureau documents. The authoritative publication point for rule text and effective dates.
Technical references
- Docker Distribution — Registry HTTP API V2 specification. The manifest and blob endpoints used by the lineage script.
- OCI Image Format specification. Manifest, index, and config blob shapes.
- NVIDIA CUDA container images on Docker Hub. Tag flavours (
base,runtime,devel) and their contents. - SLSA provenance specification. The model behind
provenance: mode=max. actions/attest-build-provenance. The GitHub Action used to push attestations to the registry.- SPDX and CycloneDX. The two SBOM formats worth supporting in CI.
More posts

What the Cyber Resilience Act Actually Requires From a Release Pipeline
Map the EU Cyber Resilience Act’s vulnerability disclosure, security update, and SBOM requirements onto CI/CD pipelines and dependency-management tools.

Auditing VS Code 1.147's Scheduled AI Agents: Model Routers, Permissions, and Reproducible Runs
VS Code 1.147's scheduled AI tasks, model routers, and browser control turn the editor into an autonomous task runner, raising hard questions about permission boundaries, audit logging, and reproducible CI runs.

Using AbortSignal.any to Compose Timeout and Cancellation Signals in fetch
Learn how to use AbortSignal.any to combine timeout and user cancellation signals in fetch requests for more robust async operations.
Loading comments…