— WP objectives
Leader: Hélène Coullon
- Model and specify Infrastructure-as-Code (IaC) and reconfiguration languages more clearly in order to provide guarantees for these languages or for programs written with these languages.
- Contribute to more expressive (re)configuration languages
- Facilitate the design and writing of IaC-type scripts.
- Design immutable deployment approaches for bootstrapping problems on heterogeneous resources
— Missions
One of the key aspects of a massively distributed and geo-distributed infrastructure is the automation of the provisioning process for distributed software elements. This process can be performed manually by operators on a few servers and for a few software components, but this is not feasible for applications and infrastructures on the scale of the continuum between edge and cloud. In addition to the initial provisioning of software components, at the scale under consideration, it is also essential to have mechanisms for dynamically changing the current configuration (reconfiguration) of software components already provisioned (updating, restarting in case of failure, etc.).
— Tasks description
T2.1 Modeling and formalization of procurement and configuration languages
We are particularly interested here in a family of languages that “codify” the provisioning of infrastructures (resources) and their configuration: “Infrastructure-as-Code” (IaC).
The first part of this task will involve understanding the theoretical and practical foundations of the IaC configuration languages (CUE, HCL, KCL), which have emerged from the industrial world with specifications that are informal at best.
Provisioning languages can be seen as a specialization, or (depending on the case) as a superset of configuration languages. They are dedicated to resource reservation and deployment on these resources (virtual machines, containers, Cloud providers etc.). We will also be looking at this type of language, in particular the TOSCA language, which has the advantage of being a standard, and the Terraform and Pulumi languages.
A second part of this task is to study how to provide programming support for users of IaC languages. First, we will study the modeling of variability inherent in deployment descriptors and IaC descriptors. The aim is to develop code support tools for users of IaC languages. Deployment descriptors and IaC scripts are massively configurable, requiring tools for reasoning about a configuration or family of configurations.
We will then look at how to implement machine learning techniques (linked to the SPIREC sub-project) to help users of IaC languages improve their deployment codes (static analysis of linters).
T2.2 Efficient, secure and competitive reconfiguration
After initial deployment, it is necessary to be able to dynamically reconfigure the software elements deployed.
As they affect the services provided and consumed, reconfigurations are critical operations for operators and users, and must remain as transparent and secure as possible to avoid inconsistent states of the software elements concerned. To facilitate the security of reconfigurations, so-called “immutable” methods are sometimes preferred, but this method is resource-intensive. In contrast, in this task we want to investigate verified “in-place” reconfiguration of software elements.
In particular, we’ll focus on the following aspects, which have received little attention in the literature :
- Decentralising the control of deployment and reconfiguration to be tolerant of network interruptions or failures,
- Verification (certification) of reconfiguration or adaptation languages,
- The study of concurrent (conflicting) reconfigurations and their resolution.
T2.3 Bootstrapping on heterogeneous resources and “rebuildability
This task addresses a special case of the deployment problem, the bootstrapping problem, i.e. the initial deployment of the software stacks needed to run infrastructures and systems (“bootstrapping”). In particular, this task focuses on bootstrapping when resources are heterogeneous and massively geo-distributed.
More specifically, the task will investigate functional and immutable approaches to building environments such as Nix.
This task will have strong links with the SILECS project. In particular, the research could lead to future tools for building experiments such as Enos, EnosLib and NixOS-Compose.
Other Work packages
