Infrastructure as Code for Heterogeneous Computing

Setting up an infrastructure for application deployment is a non-trivial task. We usually simplify the task by using the Infrastructure as Code (IaC) approach. Through IaC we set-up software defined infrastructure, able to run applications. Several tools and platforms have been developed to describe the system and to implement the actual deployment of the application (e.g., Puppet, Chef, Ansible, Terraform, etc.). When the infrastructure is heterogeneous (e.g., combination of Cloud and HPC) the challenges to set up a collaborative infrastructure is even harder, as the paradigms and environments differ significantly. Cloud infrastructure is focusing on servers, events, functions, while the HPC infrastructure is procedural and takes the application and merely executes it, usually on bare metal. As expected, the applications deployed on the respective systems differ in their dynamics and longevity. Whilst deployment of applications on the Cloud can be solved with the aforementioned tools, the HPC systems are in this respect in their infancy - the application is usually scheduled to be executed on a pre-defined set of processors and from that point on, the scripts merely gather input data, execute the application and then organize the output data. Merging the two approaches is thus currently rather hard and requires an explicit boundary between the Cloud and HPC parts of the application, posing a significant issue for the overall modelling and thus set-up of the system with the IaC approach. SODALITE, an H2020 project, is targeting simplification of the application deployment complexity while retaining or improving application performance on targeted HPC heterogeneous and cloud systems. The application deployment is abstracted through modelling of application's component relationships, policies and performance. The application is deployed using appropriate container technologies, matching the targeted heterogeneous HPC and cloud-based platforms. The starting point is the definition of the system and the application within an AI-supported IDE, using a straightforward, TOSCA-similar language. The smart IDE backed with the Graph DB knowledge base supports the user with the suggestions on how the system and application could (or should) be modelled. In the next general step, this definition is executed through an orchestrator, resulting in an execution of the application within the software-defined environment. In cases where the source code is available, it is optimised for the targeted infrastructure before execution. This step ensures that the application performance is not lost due to abstraction. However, in all cases, the execution of the application is monitored, as SODALITE is using machine learning and controltheory approaches to improve runtime performance. SODALITE is currently in the middle of its development thus not all of its functionalities are available. Whilst we first addressed the typical private Cloud infrastructures (e.g. OpenStack) and HPC (e.g. Torque job scheduler) using containers to encapsulate the applications, there is still work to be done to address public Clouds (e.g. AWS) and other HPC schedulers (e.g. Slurm). The IDE is functional, however it still requires further improvements and enhancements. Finally, not all optimisation approaches are developed at the moment. The aim of the proposed approach is to flatten the learning curve for Ops enabling them to concentrate on domain problems, resulting in lower overall costs of development and application lifecycle management.