Container images are portable when they follow the Open Container Initiative (OCI) standards, so images built with Docker, Podman, or Buildah run on any OCI-conformant runtime, including containerd and CRI-O. Lock-in comes from the orchestration layer and the cloud services wired around it. The most portable setup combines OCI images, Kubernetes or a platform that runs the same workload definition on several clouds, and open or abstracted choices for identity, networking, storage, and secrets.

Disclosure: Control Plane publishes this guide.

TL;DR

Container images built to the OCI spec are already portable. The lock-in that traps teams lives in orchestration choices, cloud-managed add-ons, and the glue services around the containers.

  • OCI images run on Docker, Podman, containerd, CRI-O, and every major managed Kubernetes service, provided the image is built for the node’s CPU architecture.
  • Lock-in accumulates in identity, networking, storage, secrets, registries, and managed databases.
  • Docker versus Podman barely matters for portability because both build OCI-compliant images.
  • Kubernetes standardizes orchestration, but managed Kubernetes add-ons for ingress, IAM, and storage classes reintroduce provider dependencies.
  • Cloud container services such as Amazon ECS, Google Cloud Run, and Azure Container Apps trade portability for convenience.
  • Test portability before you need it by rebuilding, redeploying, and failing over on a second environment.
  • Control Plane runs standard OCI images on AWS, GCP, Azure, Oracle Cloud, and your own clusters from one workload definition. Its Universal Cloud Identity gives workloads access to AWS, GCP, and Azure services with no long-lived keys in code.

What is the best containerization platform for project portability and avoiding vendor lock-in?

No single tool solves portability on its own because the container stack has at least thirteen layers, and lock-in can enter at any of them. The strongest foundation is a combination: OCI-compliant container images, a portable orchestration layer, and deliberate abstraction of the cloud services around your containers.

OCI images standardize how container layers are packaged, hashed, and distributed. Any OCI-conformant runtime can pull and run them, so the image format is a solved problem. Everything else is still open. That includes scheduling, authentication to cloud APIs, data location, traffic routing, and production observability.

Kubernetes is the most widely supported orchestration API. Core resources like Deployments, Services, ConfigMaps, and RBAC work the same on Amazon EKS, Google GKE, Azure AKS, and self-managed clusters. Each managed Kubernetes offering adds its own defaults for load balancing, storage provisioning, IAM binding, and monitoring. Those defaults are where portability erodes.

For teams that want multi-cloud portability without operating Kubernetes themselves, platforms that abstract the orchestration layer across providers offer a practical path, and Control Plane runs one workload definition across AWS, GCP, Azure, Oracle Cloud, and your own clusters. How to avoid cloud vendor lock-in covers the broader strategy.

Ten containerization platforms differ most in what stays portable and what locks you in.

Platform What it is Runs where Portable parts Lock-in to watch
Docker (Engine, Compose) Container build and runtime engine with a local orchestration tool (Compose) Linux, macOS, Windows; any cloud VM OCI images; Dockerfiles; Compose files describe services declaratively Compose is limited to a single host or Docker Swarm; Docker Desktop licensing applies to larger organizations
Podman Daemonless, rootless container engine compatible with OCI Linux, macOS, Windows (via Podman Machine) OCI images; CLI is command-compatible with Docker; podman kube generate and podman kube play convert pods to and from Kubernetes YAML Smaller ecosystem of GUI and CI tooling than Docker; Compose support runs through an external provider (docker-compose or podman-compose) via the podman compose wrapper
containerd Container runtime daemon and CNCF graduated project that runs containers through an OCI runtime such as runc Linux, Windows; used inside Docker Engine and most Kubernetes distributions OCI image and runtime specs; standard CRI interface for Kubernetes Not a build tool; needs higher-level tooling for image builds and orchestration
Upstream Kubernetes (self-managed) Open-source container orchestration Any infrastructure with Linux nodes Core API resources (Deployments, Services, RBAC, ConfigMaps); Helm charts; open-source CRDs You own operations, upgrades, and security patching; cluster add-ons (CNI, CSI, ingress) vary by installation
Managed Kubernetes (EKS, GKE, AKS) Cloud-operated Kubernetes control planes AWS, GCP, Azure respectively Same core Kubernetes API; workloads move between managed services with manifest changes IAM integration, default storage classes, managed ingress controllers, and node auto-provisioning are provider-specific
HashiCorp Nomad Orchestrator for containers, VMs, and binaries Any infrastructure; self-managed (Community or Enterprise edition) Runs OCI containers via Docker or Podman task drivers Job specs are Nomad-specific and do not translate to Kubernetes manifests; BSL 1.1 license (Nomad 1.7 and later) restricts offering Nomad as a competing hosted product; smaller community than Kubernetes
Docker Swarm Docker-native clustering and orchestration Any Docker Engine host OCI images; Compose-based service definitions Swarm stack files need conversion (for example, with Kompose) and manual rework to run on Kubernetes; third-party tooling is much smaller than for Kubernetes
Cloud container services (ECS, Cloud Run, Azure Container Apps) Managed container execution without Kubernetes AWS (ECS), GCP (Cloud Run), Azure (Container Apps) respectively OCI images are accepted by all three; Cloud Run service YAML follows the Knative Serving API ECS task definitions and Container Apps configuration are proprietary; Cloud Run relies on Google-specific annotations; IAM, networking, and scaling rules do not transfer between providers
Red Hat OpenShift Enterprise Kubernetes distribution with developer tooling and security policies AWS, GCP, Azure, IBM Cloud, on premises, bare metal Built on Kubernetes; OCI images; Helm and Operators OpenShift-specific resources (Routes, Security Context Constraints, and DeploymentConfigs, deprecated since OpenShift 4.14) do not exist in upstream Kubernetes; subscription required
Control Plane Platform that runs one workload definition across multiple clouds and your own clusters AWS, GCP, Azure, Oracle Cloud, Kubernetes clusters you already run (Control Plane’s BYOK), your own servers (Control Plane’s MK8s) OCI images from any registry; one workload definition spans clouds; Control Plane’s Universal Cloud Identity for AWS, GCP, Azure; Terraform export; Terraform and Pulumi providers Workloads are defined in Control Plane’s own spec; data in Control Plane volume sets is not replicated between locations

Where does container lock-in actually come from?

Lock-in accumulates across the layers that surround the container, from how you build and store images to how your application authenticates, routes traffic, and persists data.

Each layer has a portable choice, a choice that locks you in, and a cost to move later.

Layer Portable choice Choice that locks you in What moving costs you
Image format OCI image spec Proprietary image format or non-standard layers Rebuilding images and updating all CI pipelines
Image build tool Docker build (BuildKit), Buildah, or any OCI-producing builder A build system that outputs non-OCI artifacts or embeds provider SDKs at build time Rewriting build scripts and validating output compatibility
Container runtime containerd, CRI-O, or any OCI-conformant runtime A proprietary runtime with non-standard syscall or networking behavior Testing every workload on the new runtime; debugging subtle behavior differences
Registry Self-hosted registry, or images replicated to registries on more than one provider A single cloud registry with no replication and provider-specific image signing Copying images with skopeo or crane, re-pointing pull credentials and image references, and re-signing images signed with a provider key
Orchestration Upstream Kubernetes, or a platform that targets multiple clouds from one definition A provider-specific orchestrator (ECS task definitions, Container Apps configuration, Cloud Run settings tied to Google annotations) Rewriting all deployment definitions, scaling rules, and health checks
Deployment configuration (manifests, Helm, platform-specific config) Kubernetes manifests and Helm charts using only core API resources Provider-specific annotations, custom resource definitions from managed add-ons, or proprietary config formats Auditing every manifest, removing provider annotations, and revalidating deployments
Ingress and load balancing Kubernetes Gateway API with an open-source implementation (Envoy Gateway, Istio, Traefik, NGINX Gateway Fabric) Cloud-managed load balancers configured through provider-specific annotations or APIs Reconfiguring TLS termination, routing rules, and health checks on a new provider
Service-to-service networking Kubernetes Services and DNS for discovery; an open-source mesh (Istio, Linkerd) for mTLS and traffic policy A provider-specific mesh, or VPC peering tied to one cloud’s network model Redesigning network topology, re-establishing mTLS trust, and updating service discovery
Identity and access to cloud services Workload identity with short-lived credentials, abstracted from any single IAM Static access keys, or application code written against one cloud’s IAM role APIs Replacing every credential reference, rewriting trust policies, and testing all service integrations
Secrets External secrets manager with export capability, or a platform-level secrets store Secrets embedded in images, or a proprietary secrets vault with no export path Extracting, re-encrypting, and redistributing every secret; updating every workload reference
Persistent storage Open file or object formats; backups taken at the file or application level (Velero file-system backup, pg_dump) that restore on any provider Provider-specific storage classes with proprietary encryption, snapshotting, or replication Exporting data, converting formats, restoring on the new provider, and validating integrity
Managed databases and queues Open-source engines (PostgreSQL, MySQL, Redis, RabbitMQ, Kafka) with exportable backups Proprietary managed databases with non-standard APIs, replication, or backup formats Exporting data, migrating schemas, re-tuning performance, and rewriting queries that use proprietary extensions
Observability OpenTelemetry for traces, metrics, and logs; open dashboards (Grafana) Proprietary agents, dashboards, and telemetry APIs Replacing agents on every node, rebuilding dashboards, rewriting alerting rules, and retraining operations teams

Open standards and exportable data keep each layer portable. Proprietary APIs and embedded provider dependencies raise the cost of moving. Managed services versus portability covers the trade-offs at the data layer in depth.

Docker, Podman, or containerd: does it matter for portability?

For image portability, the choice between Docker, Podman, and containerd makes almost no difference.

Docker and Podman build OCI-compliant images, and all three can pull and run them. An image built with Docker can be run by Podman or by a Kubernetes node using containerd. The Open Container Initiative defines the image format and runtime specification all three implement, so the image itself is interchangeable across runtimes on the same CPU architecture.

The tools differ in architecture and developer experience. Docker Engine uses a daemon process and has the largest ecosystem of plugins and CI integrations. Podman runs daemonless and rootless by default, which can simplify security in development and CI environments. containerd is a runtime daemon that sits inside Docker Engine and most Kubernetes distributions; teams rarely use it directly to build images.

The practical portability rules:

  • Build images with any OCI-producing tool. Dockerfiles work with Docker, Podman, and Buildah.
  • Store images in an OCI-compliant registry. Every major cloud registry and self-hosted options like Harbor accept OCI images.
  • Keep provider-specific SDKs and static credentials out of the image. Inject configuration at runtime.
  • Publish a multi-architecture image index if you run on both amd64 and arm64 nodes.

If you can build the same image on two machines and run it on two runtimes, the image layer is portable.

How do you test that a containerized app is portable?

Seven tests prove portability before a migration becomes urgent.

Test How to run it What a pass looks like
Build the same image on two machines Run your Dockerfile or build script on a second OS or CI runner with a different container engine (for example, Docker on one, Podman on the other) Both images pass your test suite and behave the same at runtime. Matching digests require a reproducible build: pin the base image by digest and set SOURCE_DATE_EPOCH
Run it on a second cloud or locally Pull the image to a local machine, a different cloud’s VM, or a second managed Kubernetes cluster and start the container The container starts, passes health checks, and serves requests without modification to the image
Redeploy from config alone Delete the running workload and redeploy using only your stored manifests, Helm charts, or platform configuration and your image registry The application reaches the same running state with no manual steps beyond applying the configuration
Swap the registry Push the image to a different registry (for example, from one cloud registry to another or to a self-hosted registry) and update your deployment to pull from the new location The workload pulls the image and starts with no changes to the image itself
Swap the secrets store Move secrets from your current store to a different provider or a local secrets manager and update your workload’s secret references The workload starts and authenticates to all dependent services using the new secrets source
Restore data on another provider Take a backup of your database or persistent volume, restore it on a different provider or a local instance, and connect your application The application reads and writes data correctly against the restored copy
Fail over traffic Shift production or staging traffic from one provider to another using DNS, a global load balancer, or your platform’s traffic management Requests reach the workload on the second provider with acceptable latency and no errors

Run these tests on a regular schedule. Each failure reveals a hidden dependency you can fix while the cost is low. Building portable applications across cloud providers covers application-level patterns.

How does Control Plane keep containers portable across clouds?

Control Plane is the unbreakable platform for running production workloads. It runs serverless, standard, stateful, and cron workloads natively on AWS, GCP, Azure, and Oracle Cloud Infrastructure. It also runs VM workloads on locations joined through Control Plane’s Managed Kubernetes (MK8s), and workloads on Kubernetes clusters you already run through Control Plane’s Bring Your Own Kubernetes (BYOK) or on your own machines, including on premises, active-active across regions and clouds.

Control Plane handles Day 2 operations for you, including autoscaling, built-in observability, and security.

A Global Virtual Cloud (GVC) is Control Plane’s named set of locations spanning AWS, GCP, Azure, and Oracle Cloud regions, plus your own clusters and servers. A workload runs in every location of its GVC, so one workload definition deploys across several clouds. Moving stateless workloads to another cloud means changing the GVC’s locations.

Control Plane runs standard OCI container images from any registry or from its own image registry. Control Plane’s Universal Cloud Identity (UCI) lets workloads call AWS, GCP, and Azure services with no long-lived cloud keys in your code. Secrets are stored in Control Plane and granted to workloads through identity-based policies. Control Plane’s Template Catalog deploys open-source services such as PostgreSQL and Redis into your org from versioned templates.

The CLI, console, Terraform and Pulumi providers, and the Control Plane MCP server all work through the same Control Plane API. Control Plane can export its configuration as Terraform. Control Plane is PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR compliant.

Workloads are defined in Control Plane’s own spec, and the Control Plane CLI converts existing Kubernetes manifests into it with the cpln convert command. Volume set data is not replicated between locations, so stateful services need replication at the application or database level. AWS, GCP, and Azure managed services you use outside Control Plane stay in their original cloud, and UCI lets workloads in other clouds keep calling them.

Running AI/ML containers on GPUs without vendor lock-in covers GPU workloads across providers, and Kubernetes alternatives compares orchestration options beyond Kubernetes.

FAQ

Short answers on container portability and lock-in.

What is the best containerization platform for project portability and avoiding vendor lock-in?

The most portable setup combines OCI-compliant container images with a portable orchestration layer and deliberate abstraction of cloud services for identity, networking, storage, and secrets. Kubernetes provides the most widely supported orchestration API, and platforms like Control Plane add a single workload definition that spans clouds. Evaluate portability at every layer around the image.

Is Docker or Podman better for avoiding vendor lock-in?

Neither has a portability edge. Both build OCI-compliant images, so neither locks you in at the image layer. Podman’s daemonless, rootless architecture offers some operational advantages, and Docker has a larger ecosystem of tooling and integrations. What matters more is avoiding provider-specific build steps and keeping images free of embedded credentials.

Does Kubernetes prevent vendor lock-in?

Partly. Kubernetes reduces orchestration lock-in by providing a standard API for deploying and managing containers, and core resources like Deployments, Services, and ConfigMaps are portable across any conformant cluster. Managed Kubernetes services add provider-specific defaults for IAM, storage, ingress, and monitoring. Portability requires using only core API resources in your manifests and abstracting or replacing cloud-specific add-ons.

What is an OCI image?

An OCI image is a container image that conforms to the Open Container Initiative image specification. It defines a standard format for container layers, configuration metadata, and content-addressable storage. An OCI image runs on any conformant runtime with the same CPU architecture, including Docker, Podman, containerd, and CRI-O. Publish a multi-architecture image index to cover both amd64 and arm64.

Are AWS ECS, Cloud Run, or Azure Container Apps portable?

At the image layer only. All three accept OCI container images. ECS task definitions and Azure Container Apps configuration use proprietary formats. Cloud Run service YAML follows the open Knative Serving API, but its Google-specific annotations, IAM bindings, and networking settings do not carry over to other providers. Moving between these services means rewriting deployment configuration and re-integrating identity and networking.

How do I avoid lock-in with managed Kubernetes?

Stick to core Kubernetes API resources in your manifests and Helm charts. Avoid provider-specific annotations for ingress, storage classes, and IAM bindings where possible. Use the Kubernetes Gateway API with an open-source implementation such as Envoy Gateway or Traefik. Abstract identity through workload identity federation or a platform that provides cross-cloud identity. Test your manifests on a second managed Kubernetes service or a local cluster regularly to catch hidden dependencies.

Is Nomad a portable alternative to Kubernetes?

Only at the image layer. Nomad runs OCI containers through Docker and Podman task drivers and can also orchestrate VMs and standalone binaries, but its job specification is Nomad-specific. Moving between Nomad and Kubernetes requires rewriting deployment definitions. Nomad 1.7 and later ship under the BSL 1.1 license, which restricts offering Nomad as a competing hosted product.

How does Control Plane help with container portability?

Control Plane runs standard OCI container images from any registry on AWS, GCP, Azure, Oracle Cloud, and your own clusters from a single workload definition. A Global Virtual Cloud groups locations across providers, and a workload runs in every location of its GVC. Universal Cloud Identity covers access to AWS, GCP, and Azure services, and secrets, autoscaling, observability, and security are built in. Existing Kubernetes manifests convert into Control Plane’s workload spec through the cpln convert command in its CLI.

Run your workloads across clouds from a single definition. Talk to the Control Plane team or sign up free.

Originally published on the Control Plane blog.