PRODUCT ENGINEERING / CONNECTED BUSINESS SYSTEMS
Omnistu Global - Everything ConnectedStart a project

Delivery engineering / Docker and Kubernetes

Docker and Kubernetes.
Images, workloads and operation.

Package applications, define deployments and choose an operating model from the workload and receiving team. Scope images, clusters, delivery, security, capacity and recovery without assuming Kubernetes is required for every application.

Discuss Docker and Kubernetes requirements β†—
Contents Β· Docker and Kubernetes

Choose an image and operating boundary before a cluster.

Container work can cover Dockerfiles, builds, registries, application state, manifests, Helm, Terraform, GitOps, scaling and observability. Inventory how the application starts, stops, stores data, uses identity and connects to dependencies before selecting an orchestrator.

Plan reusable modules and reviewed image/cluster/pipeline definitions around the workload. Inspect the selected components and demonstrate acceptance on the actual environment. Reuse still needs rights, version, security and operating review.

A simpler managed container service, PaaS, Compose or an existing host may fit better than a new Kubernetes platform. Service count alone does not decide suitability or total cost. Compare availability, state, traffic, team skills, provider dependencies and operational responsibility without a universal threshold.

Source handover includes safe operating and access evidence.

Specify Dockerfiles, build inputs, dependency locks, manifests, Helm charts/values, Terraform modules, GitOps definitions, policies, dashboards, alerts and restore/release runbooks. Record actual image digests, tool/provider versions, registry retention and receiving-team setup and operation.

Cloud, registry, Git and monitoring accounts, roles, bills, keys and support responsibilities need explicit ownership. Transfer state and configuration through secure approved access; Terraform state, rendered secrets and registry credentials can be sensitive. Do not publish them in handover files or shared handover material.

Separate custom assignment from reusable modules, base images, charts, operators, packages and provider licenses. Owning configuration does not mean owning EKS/GKE/AKS or guaranteeing zero lock-in. Have the receiving team demonstrate deployment, recovery and access revocation under agreed terms.

Docker, Swarm, Kubernetes and managed services solve different problems.

Serverless containers and managed Kubernetes modes change who runs selected infrastructure. Review the actual mode and configuration before comparing bills or incident ownership.

Seven buyer decisions before container work.

Is Kubernetes needed?

Evaluate state, availability, traffic, delivery and operations first. Several containers alone do not justify a platform, and one service can still have demanding requirements.

Which provider and mode?

Compare existing identity, network, data, regions, versions, capacity and support across EKS, GKE, AKS or self-managed options.

How does the application move?

Package and test current behaviour, then decide state handling, dependencies and release compatibility before splitting services.

What will operation cost?

Estimate management, compute, storage, network, load balancers, registries, logs, backups and receiving-team work.

What must be secured?

Review images, identity, RBAC, network, admission, secrets, hosts, private data and the application’s own permission boundaries.

Does dockershim removal affect images?

Kubernetes removed its in-tree dockershim adapter; that does not prohibit running compatible Docker-built OCI images through supported runtimes.

Who runs the platform later?

Require receiver training, documented upgrades, release/restore drills, alert owners and approved ongoing terms, not an assumed fixed retainer.

Separate packaging, cluster resources and workload policy.

Define application Deployments/StatefulSets or other controllers, Services, configuration, secrets, storage, identity and network paths with clear owners. Frontend/backend/data/monitoring namespaces can organize resources, but do not by themselves create a strong security boundary.

Each service can own a chart and repository module while still sharing APIs, databases, cluster capacity, admission and release dependencies. Adding a module is not a guarantee other workloads are unaffected or that a fixed delivery interval is possible.

Helm values and Terraform modules should express selected environment/provider differences. Render and validate outputs, review plans and inspect resulting objects. A chart or template that renders successfully can still grant excessive access, select wrong pods or configure unavailable storage.

Keep application, platform and data recovery separate. An orchestrator can replace a process without repairing a corrupt record, restoring an external database or making a non-idempotent job safe to rerun.

The orders manifest is illustrative, not a complete platform.

The sample defines a backend namespace Deployment, an internal Service and an autoscaling/v2 CPU HPA. It uses a rolling strategy with maxUnavailable zero/maxSurge one, a CPU request, memory request/limit, readiness/liveness probes, non-root/read-only settings and envFrom a named Secret.

CPU/memory numbers and the probe paths are source example values, not measured production sizing.

Technical example

Source sample, not an installed backend or verified deployment. The limitations above apply.

# orders-api.yaml - Deployment, Service and autoscaler for one service
apiVersion: apps/v1
kind: Deployment
metadata:
  name: orders-api
  namespace: backend
spec:
  # no replicas field: the autoscaler below owns the pod count
  selector:
    matchLabels:
      app: orders-api
  strategy:
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1
  template:
    metadata:
      labels:
        app: orders-api
    spec:
      securityContext:
        runAsNonRoot: true
      containers:
        - name: api
          # version tag shown here is mutable; pin a digest for content identity
          image: registry.example.com/orders-api:1.8.2
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              memory: 512Mi
          readinessProbe:
            httpGet:
              path: /healthz/ready
              port: 8080
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /healthz/live
              port: 8080
            initialDelaySeconds: 10
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
          envFrom:
            - secretRef:
                name: orders-api-secrets # external sync configuration is not shown
---
apiVersion: v1
kind: Service
metadata:
  name: orders-api
  namespace: backend
spec:
  selector:
    app: orders-api
  ports:
    - port: 80
      targetPort: 8080
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: orders-api
  namespace: backend
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: orders-api
  minReplicas: 3
  maxReplicas: 12
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

Build identity and compatibility need more than a short tag.

Use suitable minimal bases, multi-stage builds and explicit dependencies to keep build tooling and unnecessary files out of the runtime where practical. A slim or distroless image still needs compatible libraries, certificates, timezone/runtime data and diagnostic/recovery plans.

Order build inputs to reuse useful cache layers, but do not promise a code change always rebuilds exactly one layer. Build arguments, base updates, dependency resolution, cache state and instructions determine invalidation and output. Avoid secrets in layers, arguments or copied files; use supported secret handling.

Promote an inspected digest and retain provenance, dependencies, signatures/attestations and the authorized registry path as appropriate. A vulnerability scan is time-bound evidence of known findings, not proof the image is safe or free of unknown vulnerabilities.

Build the required architectures deliberately and test them. A multi-platform image index can select architecture-specific manifests; one digest label does not mean every platform executes identical machine code or behaviour. Kernel, CPU, runtime and external services still differ.

Reconciliation is not a complete rollback of business state.

Argo CD or Flux can reconcile desired definitions with a cluster. Choose sync, prune, self-heal, permissions and drift-notification policies explicitly. Versioned Git improves traceability; it does not make every live change impossible or every commit safe.

Argo CD’s documented automated-sync behaviour includes restrictions on rollback while auto-sync is enabled. A Git revert or desired-state change can be part of recovery, but databases, volumes, external effects, removed resources and credentials do not automatically return to their old state.

Define approvals, artifact identity, environment values, cluster/namespace targeting, secrets access and deployment concurrency. Avoid direct pipeline and GitOps controllers simultaneously fighting over the same resource fields.

Rehearse failed rollout, unavailable image, broken probes, wrong configuration, partial migration and controller outage. Verify actual recovered state and representative business flows rather than claiming one command always makes rollback instant.

Pod, node and event-driven scaling have separate prerequisites.

HPA changes replica counts from configured metrics; VPA changes selected resource recommendations/requests under its mode; KEDA can connect event demand to scaling. Install and configure the actual components and coordinate controllers that affect the same workload.

Metrics Server or selected metrics adapters, resource requests, availability of nodes, quotas, startup time and downstream capacity affect scaling. A desired pod count is not available capacity. Queue backlogs, CPU, memory and request latency describe different bottlenecks.

Node autoscaling responds to its supported signals and constraints. DaemonSets, disruption budgets, local storage, affinity and remaining workload can prevent consolidation. It does not simply remove every idle node on a clock or guarantee capacity is instantly purchasable.

Measure requests and limits against representative workloads. Missing CPU limit is not inherently a defect; memory/CPU choices have different enforcement and availability effects. Review burst, eviction, OOM, retry and cost behaviour rather than setting a universal chart default.

Replicas and zones do not remove every interruption.

Design replica placement, zone/storage dependencies, readiness, shutdown and load-balancer behaviour together. Several replicas can share one failure domain or one overloaded database. A managed control-plane SLA is not the application’s availability guarantee.

PodDisruptionBudgets limit selected voluntary evictions through cooperating paths. They do not prevent involuntary failures, and Deployment rolling updates follow their own update strategy rather than being universally blocked by a PDB.

Separate startup, readiness and liveness criteria. A liveness check that restarts every pod when one dependency fails can worsen an outage. A readiness endpoint that reports success before the app can serve hides a bad release.

For canaries or blue-green releases, define traffic splitting, metrics, observation, automated/manual stop and rollback/reconciliation. A mesh or rollout controller name is not proof the required checks exist or that schema changes remain backwards compatible.

Namespace separation is not sufficient isolation.

Use deliberate service identities, least-privilege RBAC, cloud identity integration and revocation tests. Removing a person from one identity system does not necessarily revoke every cached token, certificate, service-account key or separately granted role immediately.

NetworkPolicy needs an enforcing network implementation. Creating a policy on a cluster without support has no effect. Review selected pods, ingress and egress directions, additive allow rules, DNS and provider/host-network behaviour; namespace names do not automatically deny traffic.

Apply the selected Pod Security Admission/admission policies and runtime controls with compatibility tests. Kyverno, OPA Gatekeeper or a CIS scanner can provide evidence for specific checks, not proof the entire system meets SOC2, PCI DSS, HIPAA or GDPR.

Review host/kernel sharing, privileged containers, host mounts, registry access, supply chain, audit coverage and incident isolation. Minimal permissions still need application tenant/object/field authorization. Verify the controls in the actual cluster and obtain the appropriate use-specific compliance review.

Secret storage, injection and rotation are different controls.

Kubernetes Secret values are not protected by base64 encoding. Upstream default storage and provider-managed encryption differ; verify at-rest encryption, KMS/key access, RBAC, backup and audit configuration for the actual cluster.

Vault, External Secrets, Sealed Secrets and provider secret managers use different control and custody models. An encrypted Git object, external store or synchronized Kubernetes Secret still needs controller permissions, key protection, rotation and restore planning.

Environment injection, projected volumes, subPath mounts and application reload have different update behaviour. Test credential changes, expired tokens, revoked workload access and dependency reconnect rather than assuming every secret update is immediately consumed.

Prefer scoped identities and supported short-lived workload credentials where suitable. Keep secret values out of Git, Helm rendered output, Terraform plans/logs and test data. Record references and secure owner access in handover, not copies of credentials.

Stateful workloads need application-aware storage and restore.

Uploads, sessions, caches and databases need explicit consistency, persistence and recovery requirements. Object storage, managed databases or external caches can fit selected state, but neither moving all state out nor running it all inside Kubernetes is universally correct.

PersistentVolume/CSI availability, access modes, zonal placement, snapshots, encryption and restore permissions depend on provider/storage. A pod restart is not a disk backup, and a volume snapshot may need application-consistent coordination.

For self-managed control planes, etcd backup/restore is separate from application volumes and external data. Managed services may own control-plane recovery without exposing the same customer etcd procedure. Verify the chosen provider’s supported recovery surfaces.

Restore into an isolated authorized environment and verify cluster definitions, data, keys, users, application flows and reconciliation. A tool such as Longhorn or a backup controller does not prove every dependency is recoverable. Measure the accepted recovery time and data window.

Managed Kubernetes responsibilities vary by service mode.

EKS, GKE and AKS manage selected control-plane functions, but node responsibility varies by selected mode. GKE Autopilot and other automated offerings can manage additional node/platform tasks. Do not claim every managed Kubernetes customer operates all worker-node software identically.

Compare provider-specific identity, networks, load balancers, storage, ingress, GPU/spot capacity, versions, quotas and service limits. Similar manifests may need different values and integrations. A portable image does not make the surrounding cloud foundation identical.

Self-managed, on-premises, edge or hybrid deployments can meet specific locality/integration needs while adding control-plane, host, certificate, network, backup and upgrade duties. Air-gapped or highly restricted environments need specialized planning, not an assumed unsupported claim or compliance promise.

Confirm actual accounts, regions, billing, access and incident owners before any provision. This Services release runs separately as static testing content; it creates no managed cluster, VM, node pool or cloud obligation.

Choose supported versions and licenses, not a calendar slogan.

Check Kubernetes/provider support windows, version-skew rules, removed APIs, operators, charts, CSI/CNI, runtimes and application compatibility before upgrades. The original’s yearly-upgrade suggestion is not a universal safe maintenance rule for every supported branch.

Kubernetes dockershim removal changed the in-tree runtime integration, not the ability of compatible OCI images built with Docker to run through supported runtimes. Inspect the actual runtime, architecture and node configuration rather than confusing Docker Desktop with the cluster runtime.

Docker Desktop has its own current subscription eligibility, including organization size/revenue and government-use terms. Docker Engine/Moby open-source licensing is separate. Review the current official terms for the actual use instead of promising every commercial install is free or every Docker use requires a paid subscription.

Helm, Terraform/OpenTofu, operators, registries and commercial provider features have separate versions and terms. License and compatibility review belongs in scope; owning a Dockerfile does not transfer every upstream component or erase provider dependencies.

Three engagement shapes have different acceptance evidence.

Container migration

Package an existing application, review state and runtime behaviour, and define the selected host/cluster, delivery, monitoring and rehearsed cutover. Do not assume containerization requires a rewrite or can avoid all application changes.

Custom Kubernetes work

Scope architecture, charts, operators, mesh, policy, capacity or a focused repair from actual requirements. Agree boundaries, versions, access and receiver proof before implementation.

Ongoing platform work

Define upgrades, patches, capacity, cost reviews, incidents, restore drills and new-service onboarding. Put availability, fees, support, notice and exit terms in a current agreement rather than inheriting source retainer promises.

Six release gates need real outputs and receiver checks.

Linters, scanners and a passing pipeline prove only their checked conditions. No security scan makes an image completely safe, and a staging load test does not establish every production failure or compliance requirement.

Sixteen stack roles are selected components, not an entitlement.

The original also references GitHub Actions, provider registries, Fluentd, policy tools and rollout controllers as possible supporting scope. A list is not proof any is installed, licensed or necessary for the actual product.

Five checkpoints connect migration to receiver operation.

The source’s NDA, first-deploy, build and support intervals are not current commitments. External accounts, network approvals, capacity and dependent application changes remain visible scope. Agree dates and fees in writing before implementation.

Operation is more than a cluster management line.

Separate catalogue adaptation, container migration, custom platform work and ongoing maintenance. Services, state changes, environments, clouds, regions, mesh, operators, security and recovery needs change implementation effort. Use current written terms for the selected scope, estimate and support.

Estimate compute, cluster management, load balancers, NAT/egress, inter-zone traffic, storage, backup, registry, logs/metrics, traces and support work for the selected mode. Shared non-production clusters and interruption-tolerant capacity can help selected workloads, but increase isolation/availability design needs.

Autoscaling and right-sizing require measured assumptions and limits, not a promise of a lower bill. Budget notifications are not universally hard caps. Any paid provision or account change needs separate approval with the account owner before provisioning.

A cutover needs a post-write recovery route.

Assess current images, hosts, dependencies, state, ports, background jobs, files, sessions, network and release process. Containerize deliberately and validate behaviour before deciding whether application decomposition is justified.

For takeover, review versions, cluster-admin and workload roles, public exposure, secrets, resources, admission, policy, backup/restore, cost and drift. Prioritize safe approved changes; importing/reconciling existing resources is not permission to replace production wholesale.

Rehearse cutover with compatibility, data movement, traffic/cache/DNS behaviour, observability and stop conditions. After new writes begin, the old system may be stale. A Helm rollback, Git revert or Terraform change does not by itself reverse data or external effects.

Keep a tested route for forward repair, replay, reconciliation or a controlled freeze according to the invariant. Verify recovered applications and records, not merely a controller reporting desired pod count.

Container migration scope and supplied workload records.

The original separately describes a German logistics VM-to-GKE migration and a French retail-SaaS service migration. The former includes Terraform, Helm, Istio, networking and Prometheus/Grafana; the latter includes container builds, Argo CD, environment values and Flagger/metrics-based canary rollout.

The French passage labels itself illustrative yet presents measured deployment, rollback, volume and engineer-time outcomes. Do not convert that conflict into a verified client result. Preserve the mechanisms and request authorized acceptance evidence rather than adopting counts, timings, savings or no-downtime claims.

The German bill-reduction target is not an established saving. Legacy runtime versions in a recorded example are not a recommendation for a new deployment; verify current support and compatibility separately.

Inspect the actual cluster, manifests, image provenance, data, load and recovery evidence before planning reuse. Verify custom/third-party rights and use-specific compliance separately from a successful deployment.

Recorded sizing to verify: the German narrative names 47 legacy VMs. The separate French example names 23 Java/Node.js services, staging/pre-production/production environments and a retail-chain audience above 200. It lists Java 17/distroless and Node.js 20/Alpine as historical build choices. These are source-scenario inputs,not independently established client scale,current runtime recommendations or capacity results.

Infrastructure stories do not establish Kubernetes delivery.

VPN orchestration/subscriptions, security alert collectors and tenancy, and live-video/creator workflows can place different demands on images, clusters, storage and traffic. Validate the actual application architecture and workload before choosing Docker or Kubernetes components.

Do not adopt launch, store-approval, sales, stability, speed, cost or rating figures from those stories. Corporate-registration assertions remain excluded; current staffing, recognition, portfolio rights and client relationships remain unverified.

Diligence should request permitted examples, real demo limitations, code/dependency rights, account ownership, reference consent and technical acceptance/restore evidence. A leadership profile, facts page or recognizable tool name is a lead to check, not a substitute for proof.

Eight domains change the workload and risk model.

Multi-zone placement, autoscaling or encryption does not guarantee no downtime, unlimited demand or regulatory compliance. Verify actual application and provider boundaries for the selected domain.

Questions about Docker and Kubernetes work.

Is Kubernetes worth the complexity?

Compare workload, state, availability, team skills and operation against simpler options. No fixed service count or universal cost threshold decides it.

What does the work cost?

Get a current itemized migration/custom/ongoing quote and provider estimate with assumptions. Record scope, exclusions, usage and support assumptions in the current proposal.

What source and IaC should be delivered?

Agree Dockerfiles, charts, modules, delivery/policy definitions, versions, runbooks and secure state/account access with receiver demonstration.

How fast can a platform be ready?

Runtime, state, network, security, recovery and acceptance decide the schedule. Obtain current milestones and dependencies in writing.

Docker, Kubernetes or Swarm?

Packaging and orchestration are different decisions. Compare actual features and operations alongside managed services instead of treating every app as a Kubernetes case.

What monitoring is included?

Specify metrics, dashboards, logs, traces, SLOs, alert recipients and runbook response. None is automatically installed by a product label.

Does scope include cloud provisioning?

Only approved accounts, resources, spending and configuration in the agreed implementation. Review the plan, final costs and rollback route with the account owner before applying changes.

What happens after delivery?

Agree incident/bug boundaries, updates, capacity, restore drills, fees, support and exit terms. No fixed support promise is inherited.

How is confidentiality handled?

Agree private-data access, NDA/IP, dependency exclusions, secure state/secrets handling and revocation. Do not exchange credentials in code or documents.

Can an existing cluster be repaired?

Start from an approved audit, prioritize changes and rehearse recovery. A public page is not permission to mutate production.

Can only one component be improved?

Focused Dockerfile, chart, GitOps, scaling, policy, monitoring or cost-review work can be scoped without rebuilding the entire platform.

Can Kubernetes run on-premises or hybrid?

Yes under a suitable supported design, but control-plane, host, network, storage, certificates, upgrades and recovery need explicit owners and evidence.

Primary references for technical qualification.

Official platform, framework and API documentation checked on 17 November 2026. These support the technical checks here, not Omnistu staffing, pricing, rights, delivery or client outcomes. Recheck installed versions and configuration before implementation.

Bring the domain, dependencies and receiving-team needs.

Describe the records, users, permitted actions, integrations, existing code and operating constraints. Agree base/custom boundaries, acceptance evidence, current quote and handover before implementation.

Discuss Docker and Kubernetes requirements β†—