Infrastructure as Code (IaC), which entails the managing and provisioning of infrastructure through code instead of manual processes, has become increasingly popular in recent times. It makes managing IT infrastructure a lot easier by taking away a lot of the hassle that comes with manual management.
However, there is a new kid on the block in the land of IT infrastructure management. Infrastructure from Code (IfC) is a rapidly emerging concept and has the potential to reshape the future of serverless computing even more. But what is Infrastructure from Code? And how does this technology compare to Infrastructure as Code? We’ll show you in this article.
What is Infrastructure from Code?
Infrastructure from Code is a way of creating applications that creates, configures, and manages cloud resources understanding a software application’s source code. The unique characteristic of the technology is that it doesn’t need an explicit description to achieve this. Instead of writing low-level and control-plane specific instructions, Infrastructure from Code infers requirements from application logic and provisions the ideal cloud infrastructure. Therefore, IfC is in many ways a new and radically different approach towards rapidly and flawlessly building scalable apps.
The difference between IaC and IfC
But what are the main differences between IaC and IfC? If you use IaC, configured files are created. These contain your infrastructure specifications, making it a lot easier to edit and distribute configurations in comparison to a manual workflow. IaC also ensures that you provision the same environment every time. By codifying and documenting your configuration specifications, IaC aids configuration management and helps you to avoid undocumented, ad-hoc configuration changes.
When you work with Infrastructure as Code, the cloud provider must explicitly define your infrastructure resources in a number of separate files. The most common formats are YAML or CDK stacks. If you opt for Infrastructure from Code, the cloud provider only needs to inspect your application code. The technology then takes care of provisioning whatever underlying infrastructure your application code needs. IoC tools do this by looking for conventions and hints within your application code files.
The benefits of Infrastructure from Code
Infrastructure from Code has several significant benefits if you compare it to most related technologies. Let us take a look at the most important ones.
One of the obvious benefits of IfC is that you have to write less code when you develop or modify an application. IfC also removes the need to learn IaC languages such as CloudFormation – which have a significant learning curve for developers who are new to serverless technology – from the equation.
Modern applications should be portable. This means that you can flexibly move them across different providers and technologies without losing out on performance and functionality. IfC makes this a lot easier because the technology allows you to retain your application code needs regardless of the underlying infrastructure.
IfC makes infrastructures self-provisioning. This means that developers don’t have to deal with writing both application logic and plane-specific instructions.
IfC unburdens developers. It gives them the opportunity to fully leverage their existing programming skills, allowing them to focus on writing business logic instead of learning constantly evolving cloud services all the time. IfC effectively delivers a translation layer that automatically enables cloud best practices while simultaneously making developers hyperproductive.
The future of application development?
“If the Platonic ideal of Developer Experience is a world where you ‘Just Write Business Logic’, the logical endgame is a language + infrastructure combination that figures out everything else.” This is how proponents of IfC describe the technology. It does look IfC has the potential to become the future of modern application development because it creates pathways to previously uncharted territories in the realm of flexibility, scalability and portability.
But it may very well take us another couple of years to reach the promised land where fully matured Infrastructure from Code reigns supreme. Using the technology on cloud services that aren’t IfC-supported yet or making changes to an underlying primitive that hasn’t been exposed can still be troublesome. But we can expect these concerns to gradually decrease as IfC advances and expands, making it possible for the technology to live up to its full potential.