Tuesday, November 3, 2026

Kubernetes Errors, Translated into Plain English (Shared from LinkedIn)

Kubernetes errors can look cryptic at first glance, but in most cases they are badly named rather than truly hard to understand. Once you learn what an error is actually saying, half the debugging is already done.

For example, OOMKilled means a pod used more memory than it was given, Pending means no node has room for the workload, and a pod stuck in Terminating often means a finalizer is waiting on something that will never happen. Deepak Agrawal has gathered 25 of the ugliest Kubernetes errors into one chart, translated into plain English, so it can be saved before an on-call shift.

25 Ugliest Kubernetes Errors chart

Image: Deepak Agrawal, via the original LinkedIn post.

Source: Deepak Agrawal's LinkedIn post

Monday, November 2, 2026

Kubernetes Probes: Startup, Liveness, Readiness Explained (Shared from LinkedIn)

Found this clear explainer on LinkedIn from DevOps Universe, and it's worth keeping handy: Kubernetes has three probes, and they each answer a different question.

3 Kubernetes Probes infographic by DevOps Universe

Image: DevOps Universe, via the original LinkedIn post.

Startup probe — Has the app finished starting? It gives slow-starting apps time to boot, and liveness and readiness stay paused until it passes. If it never passes, Kubernetes restarts the container.

Liveness probe — Is the app still alive? It catches a stuck or deadlocked app, and on failure Kubernetes restarts the container.

Readiness probe — Is the pod ready to serve traffic? On failure the pod is removed from the Service so it stops receiving traffic, but it is not restarted.

Common mistakes the post calls out: using a liveness probe to check the database (one DB blip then restarts every pod), running slow apps with no startup probe (liveness kills them before they finish booting), and running with no readiness probe (users hit pods that aren't ready yet).

As the author puts it: "Startup protects the boot. Liveness protects against hangs. Readiness protects your users."

Read the original post on LinkedIn here: https://www.linkedin.com/posts/kubernetes-devops-k8s-share-7519379164957892609-O71O/

Credit: DevOps Universe on LinkedIn. This blog post is a summary with attribution, not a republication of the original.

Daily DevOps & Cloud Briefing — November 2, 2026

Daily DevOps & Cloud Briefing — Monday, November 2, 2026

A quiet weekend for new launches, so this covers the last 3–4 days, led by earnings, a critical GitLab flaw, and agentic platform moves.

1. DevOps architecture

2. Cloud

3. Enterprise technology planning

Wednesday, October 28, 2026

LinkedIn DevOps Resources — October 28, 2026

LinkedIn DevOps resources — Wednesday, October 28

Thin day for fresh LinkedIn posts — only one falls inside the last 72 hours, so the rest are dated honestly rather than padded.

Tools & resources

Study materials

Daily DevOps & Cloud Briefing — October 28, 2026

Daily DevOps & Cloud Briefing — Wed, Oct 28, 2026

1. DevOps architecture

2. Cloud

3. Enterprise technology planning

Tuesday, October 27, 2026

Shift-Left Security in Jenkins: Secrets, SAST, Dependency and Image Scanning

Security reviews at the end of a release find problems when they are most expensive to fix. “Shift left” simply means running the same checks inside every pipeline run, so a leaked key or a vulnerable dependency fails the build the day it is introduced. Here is the set of stages I add to Java pipelines.

The stages

pipeline {
  agent { label 'linux' }
  environment {
    IMAGE = "nexus.example.com:8443/apps/account-search:${BUILD_NUMBER}"
  }
  stages {
    stage('Secrets scan') {
      steps { sh 'gitleaks detect --source . --redact --exit-code 1' }
    }
    stage('Build & unit tests') {
      steps { sh 'mvn -B clean verify' }
    }
    stage('SAST + quality gate') {
      steps {
        withSonarQubeEnv('sonar') { sh 'mvn -B sonar:sonar' }
        timeout(time: 10, unit: 'MINUTES') {
          waitForQualityGate abortPipeline: true
        }
      }
    }
    stage('Dependency check') {
      steps {
        sh 'mvn -B org.owasp:dependency-check-maven:check -DfailBuildOnCVSS=7'
      }
    }
    stage('Image build + scan') {
      steps {
        sh 'docker build -t $IMAGE .'
        sh 'trivy image --exit-code 1 --severity HIGH,CRITICAL --ignore-unfixed $IMAGE'
        sh 'trivy image --format cyclonedx --output sbom.json $IMAGE'
        archiveArtifacts artifacts: 'sbom.json'
      }
    }
  }
}

What each stage catches

  • Secrets scan (gitleaks) – API keys, passwords and tokens committed to the repo. Run it first; it takes seconds.
  • SAST with a quality gate (SonarQube) – injection risks, weak crypto and bugs in your code. waitForQualityGate makes the gate a hard stop instead of a dashboard nobody reads.
  • Dependency check (OWASP) – known CVEs in third-party libraries. Start with a CVSS threshold of 7 and tighten later.
  • Image scan (Trivy) – vulnerable OS packages and runtimes in the final image. --ignore-unfixed keeps the build focused on things you can actually fix.
  • SBOM – a CycloneDX list of everything inside the image. When the next big library vulnerability is announced, you can answer “are we affected?” in minutes.

Making it stick

  1. Put these stages in the shared library, not in each Jenkinsfile, so every team gets them and updates roll out in one place.
  2. Pin scanner and tool versions and pull them through your Nexus proxy. Recent npm and PyPI compromises showed that floating tags like latest are a supply-chain risk in themselves.
  3. Have a documented exception process (suppression files with an owner and an expiry date). Otherwise people disable the stage the first time it blocks a release.
  4. Start in warning mode for a week, fix the backlog, then switch to failing builds.

The goal is not zero findings; it is that every new risk is visible, owned and decided on before it reaches production.

Blue-Green vs Canary Deployments on Kubernetes

A plain Kubernetes rolling update is fine for most changes, but it has one weakness: once the rollout finishes, every user is on the new version, and rolling back means another rollout. For risky releases, two strategies give you more control: blue-green and canary.

Blue-green: switch all traffic at once

Run the new version (green) next to the current one (blue), test it, then move the Service selector.

# two Deployments with different version labels
#   account-search-blue   labels: app=account-search, version=blue
#   account-search-green  labels: app=account-search, version=green

apiVersion: v1
kind: Service
metadata:
  name: account-search
spec:
  selector:
    app: account-search
    version: blue      # change to green to cut over
  ports:
  - port: 80
    targetPort: 8080
# cut over
kubectl patch service account-search \
  -p '{"spec":{"selector":{"app":"account-search","version":"green"}}}'

# instant rollback
kubectl patch service account-search \
  -p '{"spec":{"selector":{"app":"account-search","version":"blue"}}}'

Good for: releases you can fully test before exposure, and instant rollback. Cost: double capacity during the switch, and database changes must work for both versions.

Canary: shift traffic gradually

Send a small share of real traffic to the new version, watch metrics, then increase. Argo Rollouts makes this declarative:

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: account-search
spec:
  replicas: 10
  selector:
    matchLabels: { app: account-search }
  template:
    # same pod template as your Deployment
  strategy:
    canary:
      steps:
      - setWeight: 10
      - pause: { duration: 10m }
      - setWeight: 50
      - pause: { duration: 10m }
      - setWeight: 100

Without a service mesh or ingress integration, the weight is approximated by replica counts. With NGINX Ingress, Istio or a Gateway API controller, Rollouts can split traffic precisely. Add an AnalysisTemplate that queries Prometheus (error rate, p95 latency) and the rollout aborts and rolls back by itself when the canary looks worse than stable.

Good for: changes whose real-world behaviour you can't fully test. Cost: you need good metrics, and two versions serve users at the same time.

Which one should you use?

  • Rolling update – the default for routine changes.
  • Blue-green – big-bang releases, strict cut-over windows, or when you need instant rollback.
  • Canary – high-traffic services where a small blast radius and metric-driven promotion matter.

Whatever you pick, make database migrations backward compatible (expand, then contract). That one discipline makes every strategy here safe to roll back.