Production images
Small, reproducible images built in CI, pinned base images, non-root users, and vulnerability scanning.
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 tldr
Containerize always. Orchestrate when you have the scale and team for it.
$ anvexis facts
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: {}| Option | Good for | Watch out for |
|---|---|---|
| Docker Compose on a VM | Single-instance apps, small teams | Manual scaling and failover |
| Managed containers (ECS, Cloud Run) | Most production web services | Platform-specific configuration |
| Kubernetes | Many services, autoscaling, multi-team platforms | Operational complexity and cost |
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.
Small, reproducible images built in CI, pinned base images, non-root users, and vulnerability scanning.
The same images promoted from development to staging to production, with configuration injected per environment.
Managed Kubernetes on your cloud, or Compose on dedicated hosts, with networking and storage designed for your workload.
Terraform and Helm or Kustomize, versioned in Git, so every environment can be rebuilt.
Resource requests, limits, and autoscaling tuned from real measurements.
Network policies, secrets management, and least-privilege service accounts.
| Concern | Our approach |
|---|---|
| Filestore | Shared persistent storage or object storage, never inside the container |
| Database | PostgreSQL outside the app containers, usually managed or on dedicated hosts |
| Long-polling and workers | Separate routing for the live-chat and bus endpoints; worker counts sized from load |
| Cron jobs | Run on designated instances so scheduled jobs don't execute twice |
| Upgrades | New image per release; database migrations run as a controlled step |
| Custom modules | Built into the image from Git, so production never depends on hand-copied code |
Stage 01
Inventory the current setup, dependencies, data, and how releases happen today.
Stage 02
Write Dockerfiles, build images in CI, and run the app locally in containers.
Stage 03
Provision the target platform with infrastructure as code.
Stage 04
Restore a copy of production data and run the full system in staging.
Stage 05
Switch traffic with a rollback plan, then decommission the old setup.
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.
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.
| Measure | Why it matters |
|---|---|
| Image size and build time | Faster builds and deployments, smaller attack surface |
| Vulnerabilities by severity | Known issues in images and dependencies |
| Resource usage versus limits | Right-sizing and stability under load |
| Deployment success rate | How reliably releases reach production |
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.
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.
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.
Do you need Kubernetes?
An honest decision guide: when Kubernetes is worth its complexity, and when a VM, Docker Compose, or a managed platform is the better call.
DevOpsCI/CD automation
CI/CD pipelines with automated tests, preview environments, GitOps deployments, and zero-downtime releases with fast rollback.
DevOpsCloud architecture
Cloud architecture on AWS, GCP, Azure, and bare metal: landing zones, networking, Terraform, cost control, and hybrid setups.
Next step
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.