Skip to main content
DevOps // Containers

Containers for everything. Kubernetes only when it earns it.

Docker makes environments reproducible. Kubernetes adds scheduling, self-healing, and scaling, plus real operational overhead. We help you use the right amount of each.

~/anvexis/devops/docker-kubernetes

$ anvexis tldr

Containerize always. Orchestrate when you have the scale and team for it.

$ anvexis facts

Images
Small, pinned, scanned
Orchestration
Compose · Kubernetes
Rollouts
Rolling · blue/green

A production-minded Odoo container setup

compose.yamlyaml
services:
  odoo:
    image: registry.example.com/odoo:19.0-2026-10-01
    command: ["--workers=6", "--max-cron-threads=2", "--proxy-mode"]
    depends_on: [db]
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://localhost:8069/web/health"]
      interval: 30s
  db:
    image: postgres:17
    volumes: ["pgdata:/var/lib/postgresql/data"]
volumes:
  pgdata: {}

Compose, managed platform, or Kubernetes?

OptionGood forWatch out for
Docker Compose on a VMSingle-instance apps, small teamsManual scaling and failover
Managed containers (ECS, Cloud Run)Most production web servicesPlatform-specific configuration
KubernetesMany services, autoscaling, multi-team platformsOperational complexity and cost

Why containers, and when Kubernetes

Containers package an application with everything it needs to run: the right Python version, system libraries, and configuration. The same image runs on a laptop, in CI, and in production, which removes a whole class of “works on my machine” problems and makes deployments repeatable.

Kubernetes is a different decision. It schedules containers across many machines, restarts them when they fail, scales them with load, and rolls out new versions gradually. Those are real benefits for systems with many services, uneven traffic, or strict uptime requirements. For a single Odoo instance with a database, it is often more machinery than the problem needs.

We start from the workload, not the tool. Many clients run well on Docker Compose on one or two well-managed servers, or on a managed container platform. When Kubernetes is the right answer, we build it to be operated by your team, not just by us.

What we deliver

Production images

Small, reproducible images built in CI, pinned base images, non-root users, and vulnerability scanning.

Environment parity

The same images promoted from development to staging to production, with configuration injected per environment.

Cluster setup

Managed Kubernetes on your cloud, or Compose on dedicated hosts, with networking and storage designed for your workload.

Infrastructure as code

Terraform and Helm or Kustomize, versioned in Git, so every environment can be rebuilt.

Scaling and limits

Resource requests, limits, and autoscaling tuned from real measurements.

Secure defaults

Network policies, secrets management, and least-privilege service accounts.

Running Odoo in containers: what matters

ConcernOur approach
FilestoreShared persistent storage or object storage, never inside the container
DatabasePostgreSQL outside the app containers, usually managed or on dedicated hosts
Long-polling and workersSeparate routing for the live-chat and bus endpoints; worker counts sized from load
Cron jobsRun on designated instances so scheduled jobs don't execute twice
UpgradesNew image per release; database migrations run as a controlled step
Custom modulesBuilt into the image from Git, so production never depends on hand-copied code

Migration to containers

  1. Stage 01

    Assess

    Week 1

    Inventory the current setup, dependencies, data, and how releases happen today.

  2. Stage 02

    Containerize

    Week 1–2

    Write Dockerfiles, build images in CI, and run the app locally in containers.

  3. Stage 03

    Platform

    Week 2–3

    Provision the target platform with infrastructure as code.

  4. Stage 04

    Rehearse

    Week 3–4

    Restore a copy of production data and run the full system in staging.

  5. Stage 05

    Cut over

    Week 4–5

    Switch traffic with a rollback plan, then decommission the old setup.

Container myths

Myth: Kubernetes makes everything more reliable.

Reality: Only if it is operated well. A misconfigured cluster adds failure modes. Reliability comes from design, monitoring, and practice.

Myth: Containers are a security boundary like a VM.

Reality: They share the host kernel. Isolation needs non-root containers, minimal images, and proper policies.

Myth: You should put the database in Kubernetes too.

Reality: You can, but stateful databases are easier to run on managed services or dedicated hosts unless your team has the experience.

Common pitfalls we help you avoid

The first pitfall is adopting Kubernetes because it is popular. It brings real operational overhead, so we compare it honestly with simpler options and only recommend it when the workload needs what it offers.

The second is copying a laptop setup into production. Development images often run as root, include build tools, and store data inside the container; production images need to be small, locked down, and stateless.

The third is skipping resource limits. Without requests and limits based on real measurements, one busy service can starve others and make the whole platform unpredictable under load.

What we measure

MeasureWhy it matters
Image size and build timeFaster builds and deployments, smaller attack surface
Vulnerabilities by severityKnown issues in images and dependencies
Resource usage versus limitsRight-sizing and stability under load
Deployment success rateHow reliably releases reach production

Who does what

We handle

  • Dockerfiles, images, and build pipelines
  • Platform setup as code
  • Runbooks, monitoring, and training

Your team handles

  • Application knowledge and testing
  • Approving the target architecture
  • Day-to-day operations after handover

A worked example

Consider a company running Odoo plus two small integration services on one large server, deployed by copying files over SSH. Updates are rare and nerve-racking. Containerizing each service, building images in CI, and running them with Docker Compose on two smaller hosts makes releases repeatable and lets one host take over if the other fails.

Kubernetes isn't needed for this setup, so the team avoids its overhead. If the business later adds more services or needs autoscaling, the same images move to a managed cluster with little rework.

Before you start

  • List of services and their dependencies
  • Where data and files are stored today
  • How releases happen now
  • Uptime expectations for each service

What success looks like

Success is releases that are boring: the same image tested in staging runs in production, deployments take minutes, and anyone on the team can roll back.

What the official docs commit you to

Kubernetes describes itself as a platform for managing containerized workloads, and states plainly that it is not a traditional, all-inclusive PaaS and doesn't provide databases, caches, or message buses as built-in servicesSource [1]. Its release policy maintains branches for the three most recent minor releases, each with roughly a year of patch supportSource [2], so a cluster means a yearly upgrade.

Good container images matter whatever runs them. Docker's best practices recommend multi-stage builds, a .dockerignore file, pinning base images to a digest for supply-chain integrity, and switching to a non-root user when a service doesn't need privilegesSource [3]. We apply all of them to Odoo and application images.

Frequently asked questions

Can Odoo run on Kubernetes?
Yes, with care around file storage, long-polling, and cron workers.
Do you use managed Kubernetes?
Yes. EKS, GKE, or AKS removes control-plane maintenance.
How do you handle secrets?
With a secrets manager or sealed secrets, never in images or repositories.
How are images kept secure?
Minimal base images, pinned versions, and vulnerability scanning in CI.
Can we keep running on VMs?
Absolutely. Containers on VMs is a perfectly good architecture for many teams.
Which Kubernetes do you use?
Usually the managed service on your cloud, such as EKS, GKE, or AKS, or a lightweight distribution for on-premise setups. We match it to your team's skills.
Can you containerize our legacy application?
Usually yes. We assess dependencies first; some applications need small changes to logging, configuration, or file storage.
Will our team be able to run it?
That's the goal. We document the setup, write runbooks, and train your team as part of handover.
Does Odoo.sh replace the need for this?
For many Odoo-only setups, yes. Containers make sense when you also run other services, need specific hosting, or outgrow Odoo.sh limits.
Do containers make Odoo faster?
Not by themselves. Performance comes from worker sizing, database tuning, and caching; containers make the setup consistent and repeatable.
Can we run development and production the same way?
Yes. The same images run everywhere, with configuration and data differing per environment.
How are container images updated for security?
Base images are rebuilt on a schedule and scanned automatically, so patches arrive through the normal pipeline.
Can you migrate us from Docker Compose to Kubernetes later?
Yes. With proper images and configuration already in place, moving to a cluster is a planned step rather than a rewrite.
Do you support on-premise clusters?
Yes, using lightweight Kubernetes distributions or Compose on your hardware, with the same practices as in the cloud.
Can you set up staging and preview environments?
Yes. The same images and configuration templates create staging and short-lived preview environments for each change.
Will Kubernetes manage our database?
Not by itself. Kubernetes doesn't provide databases as built-in servicesSource [1]; we usually keep databases on managed services or dedicated servers.
How do you secure container images?
Multi-stage builds, pinned base images, minimal contents, and non-root users, following Docker's guidanceSource [3].