Immutable Container Microservice Deployment Consistency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The challenge lies in consistently deploying microservices across various environments with the same versions of software code, as external dependencies and versions can change over time, leading to inconsistent configurations and difficulties in debugging and troubleshooting.
Innovation Solution
The method involves creating an immutable container of microservices artifacts, which are deployed across different environments, ensuring consistent configurations and versions, using containerized deployment technologies like Docker and Node Package Manager, to maintain the same modules and code across development, integration, and customer environments.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If microservices use multiple external dependencies that change over time, then the system can adapt to new versions and improvements, but it becomes difficult to repeatably and consistently deploy the same versions across environments
Solution Approach 1:
The patent applies preliminary action by capturing the exact versions of all external dependencies at the time of microservice build and embedding them into the container image. This pre-packaging ensures that the same dependency versions are used across all deployment environments, eliminating version drift while maintaining the ability to adapt to new versions by simply rebuilding with updated dependencies.
Solution Approach 2:
The patent uses copying by creating immutable container images that replicate the exact runtime environment of the development system. These container copies include all necessary dependencies, libraries, and tools, ensuring that the microservice runs identically across different environments without relying on external resources or host system configurations.
2Reliability
If version pinning models are used to reference correct versions of dependencies, then version consistency can be maintained, but the pinning models can be incomplete and rely on external resources being available
Solution Approach 1:
The patent merges the microservice code with all its external dependencies, libraries, and tools into a single container image. This combination eliminates the need for separate version pinning mechanisms and external resource dependencies, as everything required to run the microservice is self-contained within the container, simplifying dependency management while ensuring version consistency.
3Reliability
If the same configuration is used across various stages of product development, then proper deployment and accurate debugging can be assured, but it becomes problematic when software code is not in the control of the developer
Solution Approach 1:
The patent creates portable container copies that encapsulate the exact development environment and dependency versions. This allows developers to maintain control over the configuration by packaging it into immutable containers, which can then be deployed to environments where the developer does not have direct control, ensuring the same configuration is used while maintaining adaptability through the containerization approach.
4Reliability
If immutable containers with pinned dependencies are created, then repeatable and consistent deployments can be achieved, but the container size and complexity increase due to including all artifacts
Solution Approach 1:
The patent applies segmentation by organizing the container image into distinct layers, with each layer representing a specific dependency or artifact. This segmentation allows for efficient storage and transmission by identifying and sharing common base layers across multiple containers, while still maintaining the complete set of dependencies required for consistent deployment. The multi-stage build process also segments the build artifacts, keeping the final runtime image smaller by excluding build-time tools and intermediate files.
Data Source
AI summary
A method, system and computer-usable medium for containerized deployment of microservices used to deploy a product or service, such as a software application running on an information handling system is described. Artifacts related to particular versions of the one or more microservices are determined. An immutable container of the artifacts is created and provided to one more environments using the same configuration of the product or service. The container is deployed in the environments during release of the product or service.