BACKGROUND IMAGE: iSTOCK/GETTY IMAGES
For enterprises that want to achieve application portability across cloud platforms, containers can be a mixed blessing. But with careful planning and the right tools, IT teams can overcome the challenges and realize the benefits of containers in multicloud.
To understand the potential benefits and risks of using containers for multicloud application portability, compare them to their alternative: VMs. Containers differ from VMs in terms of application images and what those images contain, as well as lifecycle management.
VM deployments require application images that are complete packages of an OS, middleware and application software. Because of that, those images can run on any VM that has the hardware features and resource capacities, such as CPU and memory, that match the application's requirements. And as long as the host server's hypervisor is compatible with the VM and any web services that the application image uses are available on a cloud platform, you will have no major execution issues.
Container application images, on the other hand, do not include the OS or all middleware components. As a result, they depend on the container host and the container software itself. This means, if containers require different application images across cloud providers, they might pose challenges in multicloud.
However, most container software wraps the application in a standard container middleware set, and that container is then portable across any host on which the container software will run. This kind of portability will generally work as long as you have the same OS and container software available on every infrastructure as a service (IaaS) host. If you don't, the containers might not be portable at all.
For multicloud planning that involves containers, choose public and private cloud resources that are all based on the same container host OS and framework. Be cautious when you use OS or middleware features if they are not supported in all OS distributions or versions. With a standard base, you will likely be able to move your containerized applications across cloud platforms without execution problems. Otherwise, you either need to avoid a multicloud deployment or move to VMs.
Operational benefits of containers in multicloud
Despite planning challenges, you can realize some benefits of containers in multicloud deployments.
On the operations side, for example, Docker and other container systems include a configuration and parameter architecture that wraps all of a workload's dependencies into a single package and makes it easier to tune a container image to particular environments. In VM systems, configuration and parameters are not managed at all -- the VM's OS, drivers and application are completely isolated from the hypervisor and underlying host.
As a result, operations personnel have to prepare new images for each cloud provider, which creates more work and can result in errors. This difference can facilitate container portability among cloud providers. However, you'll need to ensure that you isolate any provider-specific dependencies from application configuration to make the most of the capability. In other words, the more a container relies on provider-specific APIs or other features, the harder migration becomes.
Networking and multicomponent apps
Networking is another area where the benefits of containers shine. Multicomponent applications, such as those based on microservices, are common in multicloud, and those application components have to be connected. VMs have no specific network model; an application can do pretty much anything that the OS and middleware support. This makes it necessary to set up a network for application components to use in each IaaS platform you deploy in multicloud. Containers, however, presume a common subnet model for connection, which is easier to manage.
Admins can more easily scale container systems and increase their resilience through container clustering. A cluster defines a series of hosting points for application components and is portable. However, it still might take some effort to make container components scalable and resilient in multicloud, because clusters normally share a subnetwork. This might pose a challenge when they need to cross cloud platform boundaries, since different providers apply different subnetting rules or limitations that affect clustering capabilities, such as load balancing between nodes.
VMs are often a better choice to scale and increase the resilience of multicomponent applications across a multicloud deployment. This is because VMs require more deliberate networking details, which reduces the risk for error when migrated to another provider.
Container platforms, like Docker, aren't suitable for multicloud portability alone, at least not in a context of practical IT operations. DevOps tools, like Kubernetes, however, can resolve that problem, and it's likely that these tools will evolve to support the notion of a virtual cloud -- or a single model that can span private and multicloud.
Prepare for multicloud computing with this guide
Increase cloud portability with well-designed APIs
Lower the costs of multicloud integration