Container and Application Layer Remediation¶
When a scanner says a container is vulnerable, the fix is almost never "patch the container." Containers are immutable artefacts: you fix the image (or its inputs), rebuild, and redeploy. The same goes for App Service: the platform patches the OS, but runtimes, dependencies, configuration and secrets are yours.
This guide covers what to fix, how to fix it, and how to roll it out without surprising the people who own the application.
Contents¶
- Where findings land
- Working with the application platform engineer
- Base images
- Automated rebuilds
- Dependency upgrades
- Runtime upgrades
- AKS node images
- Insecure Kubernetes configuration
- App Service configuration
- Secrets handling
- Rolling out remediated workloads safely on AKS
- Rolling out safely on App Service
- Verifying the fix reached production
- Remediation checklist
Where findings land¶
| Layer | Example finding | Who changes what | Fix |
|---|---|---|---|
| Base image OS packages | openssl CVE in debian:12 layer |
Platform (base images) or app team (Dockerfile FROM) |
Rebuild on patched base; switch to minimal base |
| Language runtime | Node.js / .NET / JRE / Python CVE | App team with platform guidance | Bump runtime image tag / App Service stack |
| Application dependencies | Vulnerable log4j-core, lodash, requests, NuGet package |
App team | Upgrade dependency; regenerate lock file |
| Application code | SQL injection, SSRF from pentest/SAST | App team | Code fix |
| Container configuration | Runs as root, privileged, writable root FS, no resource limits | App/platform | Pod spec, Dockerfile USER |
| Kubernetes cluster config | Old Kubernetes version, API server public, no network policy | Platform | Cluster upgrade, config change |
| AKS node OS | Kernel CVE on nodes | Platform | Node image upgrade |
| App Service config | TLS 1.0 allowed, FTP enabled, HTTPS-only off, remote debugging on | App/platform | Site config |
| Secrets | Connection string in app settings / env / image layer / Git | App team + security | Rotate, move to Key Vault, managed identity |
Defender for Containers (powered by Defender Vulnerability Management) reports registry findings (images in ACR) and runtime findings (images actually running in AKS). Prioritise running images — a vulnerable image that nothing runs is a registry hygiene task, not an exposure.
Working with the application platform engineer¶
The remediation owner knows the vulnerability; the application platform engineer knows the deployment, the dependencies, and what breaks. Agree on a working model up front.
RACI¶
| Activity | Remediation owner | App platform engineer | App team | Release/change |
|---|---|---|---|---|
| Identify affected images/apps, prioritise | A/R | C | I | — |
| Base image updates | R | A | I | — |
| Dependency/runtime upgrades in app repos | C (opens MR or issue) | C | A/R | — |
| Configuration hardening (pod spec, site config) | R (proposes) | A | C | — |
| Rollout plan and execution | C | A/R | C | C |
| Verification in prod | A/R | C | I | — |
Hand-off package¶
When you hand a finding to the platform/app side, include everything needed to act without a meeting:
Finding(s): VM-2026-00731 (CVE-2026-XXXXX), VM-2026-00732
Priority / due: P2 / 2026-11-25
Affected: image acr-prod.azurecr.io/orders-api@sha256:ab12… (running in aks-prod-cc: ns orders, 6 pods)
Layer: base image (debian 12 openssl 3.0.x)
Fix: rebuild on debian:12 (current digest sha256:cd34…) — openssl fixed in 3.0.y-1~deb12u1
OR move to distroless/static or mcr.microsoft.com/dotnet/aspnet:10.0-noble-chiseled
Verification: Defender "running container images should have vulnerability findings resolved" clears;
`trivy image` on new digest shows 0 HIGH/CRITICAL with fix available
Rollout ask: normal release path; no config change needed
Contacts: remediation owner (you), platform on-call
Agree on standing rules so routine work doesn't need negotiation: e.g. base-image-only rebuilds with passing tests may be auto-merged and deployed to non-prod; production deployment follows the normal release train within the SLA.
Base images¶
Choose bases that minimise the attack surface¶
| Base | Size / surface | Notes |
|---|---|---|
scratch / distroless static |
Smallest | Static binaries (Go, Rust with musl or static glibc). No shell, no package manager. |
Distroless (gcr.io/distroless/*) |
Small | Runtime only (cc, java, nodejs, python). |
.NET chiseled Ubuntu (mcr.microsoft.com/dotnet/runtime-deps:*-noble-chiseled, aspnet:*-noble-chiseled) |
Small | Non-root by default, no shell, no package manager. |
Azure Linux (mcr.microsoft.com/azurelinux/base/core, distroless variants) |
Small | Microsoft-maintained, aligned with AKS node OS. |
| Docker Hardened Images | Small | Minimal, maintained, and scanned by Defender for Cloud since May 2026. |
| Alpine | Small | musl libc compatibility caveats; fast-moving fixes. |
| Debian slim / Ubuntu | Medium | Familiar; more packages → more findings. |
| Full distro images | Large | Avoid for production runtime stages. |
Fewer packages means fewer CVEs to triage and fewer tools for an attacker after compromise.
Multi-stage builds¶
Compilers, package managers and build tools stay in the build stage:
# syntax=docker/dockerfile:1.7
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY *.csproj .
RUN dotnet restore --locked-mode
COPY . .
RUN dotnet publish -c Release -o /app --no-restore
FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble-chiseled AS final
WORKDIR /app
COPY --from=build /app .
USER $APP_UID
EXPOSE 8080
ENTRYPOINT ["dotnet", "Orders.Api.dll"]
# Rust: static binary on distroless
FROM rust:1-bookworm AS build
WORKDIR /src
COPY . .
RUN cargo build --release --locked
FROM gcr.io/distroless/cc-debian12:nonroot
COPY --from=build /src/target/release/orders /usr/local/bin/orders
USER nonroot
ENTRYPOINT ["/usr/local/bin/orders"]
Pin by digest, update by automation¶
Tags move; digests don't. Pin FROM lines to a digest for reproducibility, and let a bot update the digest:
FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble-chiseled@sha256:<digest>
Renovate keeps both the tag and digest current:
{
"extends": ["config:recommended", "docker:pinDigests"],
"packageRules": [
{
"matchDatasources": ["docker"],
"matchUpdateTypes": ["digest", "patch"],
"automerge": true,
"automergeType": "pr",
"schedule": ["before 6am on monday"]
}
],
"vulnerabilityAlerts": { "enabled": true, "labels": ["security"] }
}
Internal base images¶
At scale, the platform team publishes approved base images (e.g. acr-shared.azurecr.io/base/dotnet-aspnet:10.0) rebuilt weekly from upstream with your CA certificates, timezone data, and non-root user preconfigured. App images build FROM those. One base rebuild then fixes the OS layer for every app at the next app rebuild.
Automated rebuilds¶
An image that isn't rebuilt accumulates CVEs while its source code sits unchanged. Rebuild on:
- Base image change (digest update).
- Schedule — at least weekly for production images, even with no code change.
- Dependency updates (bot PRs).
- Code change (normal CI).
ACR Tasks: rebuild when the base image updates¶
az acr task create \
--registry acrprod \
--name orders-api-base-trigger \
--image "orders-api:{{.Run.ID}}" \
--context https://gitlab.example.com/apps/orders-api.git#main \
--file Dockerfile \
--git-access-token "$GIT_TOKEN" \
--base-image-trigger-enabled true \
--base-image-trigger-type Runtime \
--commit-trigger-enabled false
Base-image triggers work when the base is in ACR (or certain public registries ACR tracks). For a pipeline-centric setup, a scheduled CI job doing docker build --pull achieves the same.
Scheduled rebuild in CI¶
# .gitlab-ci.yml (excerpt)
rebuild-weekly:
stage: build
rules:
- if: $CI_PIPELINE_SOURCE == "schedule" && $REBUILD == "true"
script:
- docker build --pull --no-cache -t "$IMAGE:$CI_COMMIT_SHORT_SHA-r$CI_PIPELINE_IID" .
- docker push "$IMAGE:$CI_COMMIT_SHORT_SHA-r$CI_PIPELINE_IID"
--pull fetches the latest base; --no-cache ensures apt-get upgrade/package layers aren't reused stale. Then the normal scan → sign → deploy stages apply (Pipeline Scanning).
Don't apt-get upgrade your way out of a stale base¶
Running apt-get upgrade in a Dockerfile hides the real problem (stale base) and makes builds non-reproducible. Fix the base; use upgrades only as a short-term bridge when upstream hasn't published a fixed base yet — and record it as an exception.
Dependency upgrades¶
Find what's vulnerable¶
| Ecosystem | Local check | Lock file |
|---|---|---|
| .NET | dotnet list package --vulnerable --include-transitive |
packages.lock.json (RestorePackagesWithLockFile) |
| Node.js | npm audit --omit=dev, pnpm audit |
package-lock.json / pnpm-lock.yaml |
| Python | pip-audit -r requirements.txt |
requirements.txt with hashes, poetry.lock, uv.lock |
| Java (Maven) | mvn org.owasp:dependency-check-maven:check, mvn versions:display-dependency-updates |
Effective POM / Gradle lockfile |
| Go | govulncheck ./... (reachability-aware) |
go.sum |
| Rust | cargo audit |
Cargo.lock |
| Any / image | trivy fs ., osv-scanner -r ., grype dir:. |
— |
govulncheck and some commercial SCA tools report reachability (whether vulnerable functions are called) — use it to prioritise, not to ignore.
Transitive dependencies¶
Most findings are transitive. Options, best first:
- Upgrade the direct dependency to a version that pulls the fixed transitive.
- Override/pin the transitive version:
- npm:
"overrides": { "vulnerable-pkg": "^2.3.4" }inpackage.json- Maven:<dependencyManagement>entry - Gradle:constraints { implementation("group:artifact:fixed") }- NuGet: add a directPackageReferenceto the fixed version (Central Package Management with transitive pinning) - Cargo:cargo update -p crate --precise x.y.z - Replace the dependency.
Bots¶
Dependabot or Renovate with grouped, scheduled PRs keeps the delta small. Large, infrequent dependency jumps are where breaking changes pile up and remediation stalls. Configure:
- Security updates: open immediately, high priority label.
- Patch/minor updates: grouped weekly.
- Major updates: separate PRs, not auto-merged.
Runtime upgrades¶
Runtimes have their own EOL clocks, often shorter than the OS:
| Runtime | Note (as of November 2026) |
|---|---|
| .NET | .NET 8 (LTS) and .NET 9 (STS) reached end of support on November 10, 2026. .NET 10 is the current LTS (supported to November 2028). Anything still on 8 or 9 stops getting security fixes now. |
| PowerShell 7 | PowerShell 7.4 (on .NET 8) and 7.5 (on .NET 9) share the same November 10, 2026 end date — update automation hosts and container images that bundle pwsh. |
| Node.js | Run Active or Maintenance LTS only; odd-numbered releases are short-lived. |
| Python | Each minor version gets ~5 years; check python.org's status page before planning. |
| Java | Stay on an LTS (17, 21, 25) with a vendor that ships updates (Microsoft Build of OpenJDK, Eclipse Temurin, etc.). |
Use endoflife.date (e.g. /api/dotnet.json, /api/nodejs.json) to report runtime EOL across your images and App Services.
Containers¶
Change the runtime base image tag (aspnet:8.0 → aspnet:10.0), update the target framework / engine version in the project, run the test suite, and redeploy. Treat runtime major upgrades as normal changes with app-team testing — they're not drop-in.
App Service (code deployments)¶
# What are apps running?
az webapp list --query "[].{name:name, rg:resourceGroup, linux:siteConfig.linuxFxVersion, net:siteConfig.netFrameworkVersion}" -o table
# Available stacks
az webapp list-runtimes --os linux
# Upgrade (test in a slot first — see below)
az webapp config set -g rg-orders -n app-orders --slot staging --linux-fx-version "DOTNETCORE|10.0"
Resource Graph across subscriptions:
resources
| where type == "microsoft.web/sites"
| extend stack = tostring(properties.siteConfig.linuxFxVersion)
| project name, resourceGroup, kind, stack, state = tostring(properties.state)
| order by stack asc
(Some site config properties are only populated via the config/web sub-resource; if stack is empty, query microsoft.web/sites/config or use the CLI.)
App Service patches the underlying OS and minor runtime versions on its own schedule; major runtime versions are your responsibility, and stacks past EOL are eventually removed from the platform.
AKS node images¶
Node OS findings are fixed by node image upgrades, not by patching nodes by hand.
| Node OS upgrade channel | Behaviour |
|---|---|
NodeImage |
Weekly-ish new node images with security and bug fixes; nodes reimaged (default for new clusters). Recommended by Microsoft's AKS upgrade guidance, paired with a maintenance window. |
SecurityPatch |
Security patches applied to nodes in place, with reimage only when needed; not supported on Windows node pools or some OS variants. |
Unmanaged |
The OS's own unattended updates; you handle reboots (kured). |
None |
Nothing automatic. |
az aks update -g rg-aks -n aks-prod-cc --node-os-upgrade-channel NodeImage
# Node OS maintenance window: Sundays 02:00–06:00 Eastern
az aks maintenanceconfiguration add -g rg-aks --cluster-name aks-prod-cc \
--name aksManagedNodeOSUpgradeSchedule \
--schedule-type Weekly --day-of-week Sunday --interval-weeks 1 \
--start-time 02:00 --duration 4 --utc-offset=-05:00
# Kubernetes version upgrades on their own channel and window
az aks update -g rg-aks -n aks-prod-cc --auto-upgrade-channel patch
az aks maintenanceconfiguration add -g rg-aks --cluster-name aks-prod-cc \
--name aksManagedAutoUpgradeSchedule \
--schedule-type Monthly --day-of-month 20 --start-time 02:00 --duration 6 --utc-offset=-05:00
Node upgrades drain nodes, so the safety of the rollout depends on your workloads: PodDisruptionBudgets, multiple replicas, readiness probes and maxSurge on node pools (see below).
Insecure Kubernetes configuration¶
Defender for Containers, Azure Policy for AKS, Trivy (trivy k8s), and kube-bench all flag the same families of issues.
Pod security baseline¶
Enforce the restricted Pod Security Standard per namespace (or the Azure Policy initiative equivalent):
apiVersion: v1
kind: Namespace
metadata:
name: orders
labels:
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: latest
pod-security.kubernetes.io/warn: restricted
pod-security.kubernetes.io/audit: restricted
A pod spec that passes restricted:
apiVersion: apps/v1
kind: Deployment
metadata:
name: orders-api
namespace: orders
spec:
replicas: 3
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 0
maxSurge: 1
selector:
matchLabels: { app: orders-api }
template:
metadata:
labels: { app: orders-api, azure.workload.identity/use: "true" }
spec:
serviceAccountName: orders-api
automountServiceAccountToken: false
securityContext:
runAsNonRoot: true
seccompProfile: { type: RuntimeDefault }
containers:
- name: api
image: acrprod.azurecr.io/orders-api@sha256:<digest>
ports: [{ containerPort: 8080 }]
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities: { drop: ["ALL"] }
resources:
requests: { cpu: 100m, memory: 256Mi }
limits: { memory: 512Mi }
readinessProbe:
httpGet: { path: /healthz/ready, port: 8080 }
periodSeconds: 5
livenessProbe:
httpGet: { path: /healthz/live, port: 8080 }
periodSeconds: 10
volumeMounts:
- { name: tmp, mountPath: /tmp }
volumes:
- name: tmp
emptyDir: {}
Cluster-level findings¶
| Finding | Fix |
|---|---|
| Public API server | Private cluster or API server authorized IP ranges / VNet integration |
| Local accounts enabled | --disable-local-accounts; Entra ID + Kubernetes RBAC or Azure RBAC |
| No network policies | Enable network policy engine (Azure CNI powered by Cilium, Calico); default-deny per namespace |
| Images from any registry | Azure Policy: allowed container images regex → your ACR only |
| Unsigned images | Image integrity (Notation signatures verified via Ratify/Azure Policy) |
| Outdated Kubernetes version | Auto-upgrade channel; stay within supported versions (or AKS LTS if you need longer) |
| Secrets in ConfigMaps / env | See Secrets handling |
Default-deny network policy per namespace:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: default-deny, namespace: orders }
spec:
podSelector: {}
policyTypes: [Ingress, Egress]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: allow-ingress-and-dns, namespace: orders }
spec:
podSelector: { matchLabels: { app: orders-api } }
policyTypes: [Ingress, Egress]
ingress:
- from:
- namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: ingress-nginx } }
ports: [{ port: 8080 }]
egress:
- to:
- namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: kube-system } }
ports: [{ port: 53, protocol: UDP }, { port: 53, protocol: TCP }]
Roll out policy changes in audit/warn mode first; restricted will reject pods that run as root, and you want to find those in a report, not in a failed production deploy.
App Service configuration¶
Common findings and fixes:
| Finding | Fix (CLI) |
|---|---|
| HTTPS not enforced | az webapp update -g RG -n APP --https-only true |
| Minimum TLS < 1.2 | az webapp config set -g RG -n APP --min-tls-version 1.2 (and --scm-min-tls-version) |
| FTP/FTPS enabled | az webapp config set -g RG -n APP --ftps-state Disabled |
| Basic auth publishing credentials enabled | az resource update --resource-group RG --name ftp --namespace Microsoft.Web --resource-type basicPublishingCredentialsPolicies --parent sites/APP --set properties.allow=false (and the same for scm) |
| Remote debugging on | az webapp config set -g RG -n APP --remote-debugging-enabled false |
| Publicly reachable when it shouldn't be | Private endpoint + publicNetworkAccess=Disabled; or access restrictions to Front Door/App Gateway only |
| No managed identity; secrets in app settings | System/user-assigned managed identity + Key Vault references |
| Outdated runtime stack | See Runtime upgrades |
| Client certificate / auth not configured where required | App Service Authentication (Easy Auth) or app-level auth |
Enforce these with Azure Policy (App Service apps should only be accessible over HTTPS, should use the latest TLS version, should have remote debugging turned off, FTPS only, etc.) in Deny for new apps once existing apps are fixed.
For custom containers on App Service, the image is yours: everything in the base image and dependency sections applies, and the platform only patches the host.
Secrets handling¶
Order of operations when a secret has leaked¶
- Rotate first. The secret is compromised the moment it's in a repo, image layer, log, or ticket. Removing it from history doesn't un-leak it.
- Check for use. Review sign-in/audit logs for the credential (Entra sign-in logs for service principals, storage account logs, DB logs).
- Replace the pattern. Move to managed identity or Key Vault so the fix doesn't recur.
- Clean up. Remove from current code; purge history (
git filter-repo) only if policy requires; rebuild images that contained it; expire the old image tags. - Prevent. Secret scanning in CI and push protection.
Prefer no secret at all: managed identity¶
| From | To |
|---|---|
| Storage account key in connection string | Managed identity + Storage Blob Data Contributor RBAC |
| SQL username/password | Entra authentication with managed identity |
| Service principal secret for Key Vault | Managed identity + Key Vault RBAC |
| Service Bus / Event Hubs SAS keys | Managed identity + data-plane RBAC; disable local auth |
| ACR admin user | Managed identity / AKS kubelet identity AcrPull |
App Service: Key Vault references¶
az webapp identity assign -g rg-orders -n app-orders
# grant the identity 'Key Vault Secrets User' on the vault (RBAC model)
az role assignment create --assignee <principalId> --role "Key Vault Secrets User" \
--scope "$(az keyvault show -n kv-orders --query id -o tsv)"
az webapp config appsettings set -g rg-orders -n app-orders --settings \
"[email protected](VaultName=kv-orders;SecretName=payment-api-key)"
Omit the secret version so rotation is picked up automatically (App Service refreshes references periodically).
AKS: Secrets Store CSI Driver + Workload Identity¶
az aks update -g rg-aks -n aks-prod-cc --enable-oidc-issuer --enable-workload-identity
az aks enable-addons -g rg-aks -n aks-prod-cc --addons azure-keyvault-secrets-provider
apiVersion: v1
kind: ServiceAccount
metadata:
name: orders-api
namespace: orders
annotations:
azure.workload.identity/client-id: "<user-assigned-identity-client-id>"
---
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: orders-kv
namespace: orders
spec:
provider: azure
parameters:
usePodIdentity: "false"
clientID: "<user-assigned-identity-client-id>"
keyvaultName: kv-orders
tenantId: "<tenant-id>"
objects: |
array:
- |
objectName: payment-api-key
objectType: secret
Mount it as a volume (csi: { driver: secrets-store.csi.k8s.io, readOnly: true, volumeAttributes: { secretProviderClass: orders-kv } }) and read the file in the app. Syncing into a Kubernetes Secret is possible but brings back the Secret object; avoid it unless the app can only read environment variables. Federate the identity with the service account:
az identity federated-credential create \
--name orders-api-fic --identity-name id-orders-api --resource-group rg-orders \
--issuer "$(az aks show -g rg-aks -n aks-prod-cc --query oidcIssuerProfile.issuerUrl -o tsv)" \
--subject system:serviceaccount:orders:orders-api \
--audience api://AzureADTokenExchange
Secrets in images¶
Scan images for secrets (trivy image --scanners secret) and never use ARG/ENV for secrets in Dockerfiles. For build-time secrets, use BuildKit secret mounts:
RUN --mount=type=secret,id=nuget_token \
dotnet restore --configfile nuget.config
Rolling out remediated workloads safely on AKS¶
A security fix that causes an outage teaches everyone to delay security fixes. Make remediation rollouts boring.
Preconditions¶
- Replicas ≥ 2 and a PodDisruptionBudget for anything user-facing:
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata: { name: orders-api, namespace: orders }
spec:
minAvailable: 2
selector: { matchLabels: { app: orders-api } }
- Readiness probes that actually check dependencies the pod needs to serve.
maxUnavailable: 0, maxSurge: 1(or a percentage) on the Deployment.- Resource requests so new pods schedule predictably.
Progressive delivery¶
| Approach | How | When |
|---|---|---|
| Rolling update | Default Deployment strategy with the settings above | Base image / dependency patch rebuilds |
| Canary | Argo Rollouts or Flagger: shift 10% → 50% → 100% with metric analysis | Runtime upgrades, larger dependency jumps |
| Blue/green | Two Deployments, switch Service selector or ingress | Major changes with a clean cutover |
| Ring by cluster | Non-prod cluster → prod canary cluster → prod | Multi-cluster estates |
Rollback¶
kubectl -n orders rollout status deploy/orders-api --timeout=5m
kubectl -n orders rollout history deploy/orders-api
kubectl -n orders rollout undo deploy/orders-api # previous ReplicaSet
With GitOps (Flux/Argo CD), roll back by reverting the commit that changed the image digest — the cluster follows Git, and kubectl rollout undo will be overwritten on the next sync.
Rolling out safely on App Service¶
Use deployment slots for anything beyond trivial:
# Deploy to staging slot
az webapp deploy -g rg-orders -n app-orders --slot staging --src-path app.zip --type zip
# or for containers:
az webapp config container set -g rg-orders -n app-orders --slot staging \
--container-image-name acrprod.azurecr.io/orders-web@sha256:<digest>
# Warm-up and smoke test against https://app-orders-staging.azurewebsites.net
# Swap (warms up the staging slot with production settings before switching)
az webapp deployment slot swap -g rg-orders -n app-orders --slot staging --target-slot production
# Roll back = swap again
az webapp deployment slot swap -g rg-orders -n app-orders --slot staging --target-slot production
Mark environment-specific settings as slot settings so they don't move during swaps. Use swap with preview for runtime upgrades to validate the app under production configuration before traffic moves.
Verifying the fix reached production¶
The registry being clean proves nothing about production.
# What digests are actually running?
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{range .status.containerStatuses[*]}{.imageID}{" "}{end}{"\n"}{end}' \
| grep orders-api
# Re-scan the running digest
trivy image --severity HIGH,CRITICAL --ignore-unfixed acrprod.azurecr.io/orders-api@sha256:<digest>
Then confirm in Defender for Cloud that the runtime recommendation (Azure running container images should have vulnerability findings resolved) no longer lists the image for that cluster. Check:
- All replicas, all clusters, all regions run the new digest.
- CronJobs and Jobs (often forgotten) reference the new image.
- Init containers and sidecars were rebuilt too.
- Autoscaling templates / Helm values / GitOps manifests point at the new digest so old pods don't come back.
- Old vulnerable tags are cleaned from ACR (retention policy /
acr purge) so nobody redeploys them.
Remediation checklist¶
- [ ] Finding mapped to layer (base, runtime, dependency, config, secret)
- [ ] Affected running workloads identified (not just registry images)
- [ ] Owner and hand-off package sent to app platform engineer / app team
- [ ] Fix implemented in source (Dockerfile, lock file, manifest, site config) — never patched in a running container
- [ ] Image rebuilt, scanned, signed, pushed
- [ ] Rolled out through rings with probes/PDBs/slots in place
- [ ] Running digests verified in every environment
- [ ] Defender/registry scan confirms closure
- [ ] Exceptions recorded for anything not fixable yet (with
.trivyignore.yaml/Defender rule tied to the exception ID) - [ ] Root cause addressed (base image cadence, bot config, policy in Deny)
References¶
- Defender for Containers vulnerability assessment — Microsoft Learn
- AKS node OS auto-upgrade and planned maintenance — Microsoft Learn
- AKS patch and upgrade guidance — Azure Architecture Center
- Pod Security Standards — kubernetes.io
- Azure Key Vault provider for Secrets Store CSI Driver — Microsoft Learn
- Microsoft Entra Workload ID for AKS — Microsoft Learn
- App Service deployment slots and Key Vault references — Microsoft Learn
- .NET support policy — dotnet.microsoft.com/platform/support/policy