How ibm/deepatlas works
Based on our analysis, Atlas is a hybrid cloud migration advisor built to support an interactive microservices application – in this case, a social network – by intelligently determining which components should “migrate” from an on-premises deployment to the cloud. The project is organized into three main parts:
Social Network Application
• This directory (./social-network) contains the full source code and Kubernetes deployment configurations for the social network. It is a microservices-based application with distinct services such as ComposePostService, HomeTimelineService, MediaService, PostStorageService, SocialGraphService, TextService, UniqueIdService, UrlShortenService, UserMentionService, UserService, and UserTimelineService.
• Within the source, you see build directories (CMakeLists, gen-cpp, gen-lua, etc.) which indicate that the services are built in a compiled language (mostly C++). In addition, YAML files under the “social-network-deploy” directory show the container orchestration, network policies, and service definitions so that these microservices can be properly deployed in a hybrid cloud environment.
Migration Advisor Module
• The “migration-advisor” directory hosts the source code that actually drives the migration recommendations. The advisor uses a data-driven approach to learn, from performance measurements, how each API and microservice interacts and what its network footprint is.
• Key submodules here include “core” (with modules for configuration, experiments, performance, cost, and availability), “experiments” (which seem to store sample or precomputed migration scenarios), and “postprocess” (which contains scripts for processing and exporting the advisor’s simulation results).
• Notably, the advisor is likely built using Python (given the presence of “app.py”, “requirements.txt”, etc.) and implements optimization routines, possibly using NSGA-II (as evidenced by the “nsga2api.py” file) to explore the trade-offs between latency, availability, and cost.
Locust Load Generator
• The “locust” directory contains the load generator that simulates user requests to the social network’s APIs. It uses Locust (a Python-based load testing framework) – with its locustfile.py and accompanying datasets – to generate the performance data that the Migration Advisor then relies on.
• This component is used to gather realistic metrics from the social network application, providing feedback to the advisor on end-to-end latency and service performance under load.
• Social Network Microservices Cluster:
• Migration Advisor:
• Load Generator (Locust):
B. Show Relationships and Interactions:
– Optionally, if the advisor ultimately outputs recommended migration plans or control signals back to a deployment orchestrator, illustrate that direction of influence.
• That the Migration Advisor processes data driven from real-world performance (load) to optimize the microservices’ distribution between on-premises and cloud deployments.
C. Highlight Architectural Patterns and Design Principles:
• Microservices architecture in the Social Network component.
• Data-driven decision making and optimization in the Migration Advisor.
• Distinguish between workload simulation (Locust), real system components (Social Network), and intelligence/analytics (Migration Advisor).
D. Annotate with Relevant Technologies:
• That the Migration Advisor is built primarily in Python (modules like app.py, nsga2api.py, etc.).
• Mention that the Social Network itself is built using a compiled language (C++) and deployed with Kubernetes (as you have numerous YAML configuration files).
• Locust as a Python-based load testing tool.
• Optionally, note any supporting libraries or frameworks that are evident (e.g., frameworks for optimization, data analytics tools, and service orchestration with Kubernetes).
• To annotate key technologies (e.g., “Kubernetes”, “NSGA-II Optimization”, “C++ Microservices”, “Python Load Generator”) near the related components.
• Remember that “don’t overthink it” means it’s beneficial to decompose as much as possible into these major logical blocks and then succinctly detail interactions between them.