Andrew Mercer
on this page

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

  1. Where findings land
  2. Working with the application platform engineer
  3. Base images
  4. Automated rebuilds
  5. Dependency upgrades
  6. Runtime upgrades
  7. AKS node images
  8. Insecure Kubernetes configuration
  9. App Service configuration
  10. Secrets handling
  11. Rolling out remediated workloads safely on AKS
  12. Rolling out safely on App Service
  13. Verifying the fix reached production
  14. 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:

  1. Base image change (digest update).
  2. Schedule — at least weekly for production images, even with no code change.
  3. Dependency updates (bot PRs).
  4. 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:

  1. Upgrade the direct dependency to a version that pulls the fixed transitive.
  2. Override/pin the transitive version: - npm: "overrides": { "vulnerable-pkg": "^2.3.4" } in package.json - Maven: <dependencyManagement> entry - Gradle: constraints { implementation("group:artifact:fixed") } - NuGet: add a direct PackageReference to the fixed version (Central Package Management with transitive pinning) - Cargo: cargo update -p crate --precise x.y.z
  3. 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

  1. 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.
  2. Check for use. Review sign-in/audit logs for the credential (Entra sign-in logs for service principals, storage account logs, DB logs).
  3. Replace the pattern. Move to managed identity or Key Vault so the fix doesn't recur.
  4. 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.
  5. 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