Infrastructure as Code (IaC) Best Practices for Multi-Cloud Deployments in Enterprises

Hari Dasari

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

174

INTERNATIONAL JOURNAL OF NETWORKS AND SECURITY (ISSN: 2693-387X)

Volume 05, Issue 01, 2025, pages 174-186

Published Date: - 12-06-2025

Doi: -

https://doi.org/10.55640/ijns-05-01-10

Infrastructure as Code (IaC) Best Practices for Multi-Cloud

Deployments in Enterprises

Hari Dasari

Expert Infrastructure Engineer Leading Financial Tech Company Aldie, Virginia

ABSTRACT

As businesses increasingly adopt multi-cloud strategies to improve cost, performance, and availability, managing
dispersed infrastructure across many providers becomes a crucial challenge. Infrastructure as Code (IaC) emerges
as a key paradigm, allowing for automation, version control, and consistency in infrastructure provisioning and
administration. This article provides a complete examination of IaC best practices for multi-cloud settings, focusing
on modular architecture, tool standardization, governance, security integration, and automation via CI/CD
pipelines. Terraform, AWS CloudFormation, and policy-as-code frameworks like OPA are all appraised for their use
in cross-cloud orchestration. The paper uses case studies and practical examples to demonstrate how firms can
streamline deployments, decrease operational risk, and assure regulatory compliance in complex enterprise
systems. These insights are intended to assist DevOps and cloud engineering teams in creating durable, scalable,
and secure multi-cloud infrastructures.

KEYWORDS

Infrastructure as Code, Multi-Cloud, Terraform, AWS CloudFormation, Enterprise Cloud Governance, DevOps
Automation, Configuration Management, Policy-as-Code, CI/CD Integration, Immutable Infrastructure

1.

Foundations of Infrastructure as Code

Infrastructure as Code (IaC) is a contemporary software engineering methodology that regards infrastructure setup
and provisioning as software objects. It facilitates the automation, documentation, version control, and validation
of infrastructure modifications using machine-readable configuration files. Infrastructure as Code (IaC) is essential
in multi-cloud setups as it standardizes infrastructure provisioning across various cloud service providers (CSPs),
hence ensuring stability and operational uniformity.

Development and Fundamentals of Infrastructure as Code: The concept of Infrastructure as Code (IaC) has
progressed from manual setup and shell scripting to standardized, declarative configuration formats and
infrastructure orchestration tools. It endorses the subsequent fundamental principles:

•

Declarative Configuration

: Specify the intended final state of infrastructure resources.

•

Idempotency

: Repeated executions result in an identical state without unforeseen side consequences.

•

Versioning

: Infrastructure configurations are subject to version management akin to application code.

•

Automation

: Infrastructure installations are automated and included into CI/CD workflows.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

175

Figure 1

illustrates the evolution of infrastructure management leading to modern IaC practices.

Figure 1: Evolution of Infrastructure Provisioning Practices

Declarative vs Imperative Approaches: IaC tools fall into two primary categories based on how infrastructure is
described:

•

Declarative

: Specifies the target infrastructure state. Tools like Terraform and AWS CloudFormation are

declarative.

•

Imperative

: Specifies the steps to reach a target state. Tools like Ansible, Chef, and Puppet follow this

model.

Table 1 compares the two approaches

Aspect

Declarative

Imperative

Focus

Desired end-state

Step-by-step instructions

Tool Examples

Terraform, CloudFormation

Ansible, Chef, Puppet

Idempotency

Inherent

Must be manually enforced

Readability

High

Medium

Flexibility

Moderate

High

Testing Complexity

Lower (due to state abstraction)

Higher (complex workflows)

Table 1: Declarative vs Imperative IaC Approaches

Components of an IaC Workflow: A typical IaC workflow in an enterprise multi-cloud environment involves the
following components:

•

Configuration Files

: YAML, JSON, or HCL files define infrastructure resources.

•

State Management

: State files (e.g., Terraform .tfstate) track the actual deployed resources.

•

Execution Engine

: CLI tools like terraform apply, ansible-playbook, or aws cloudformation deploy process

infrastructure definitions.

•

Validation and Testing

: Tools like terraform plan, kitchen-terraform, Checkov, and Terratest verify

correctness and security.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

176

Figure 2

shows the integration of IaC into a DevOps CI/CD pipeline.

Figure 2: IaC Workflow in CI/CD Pipeline

Benefits of IaC in Multi-Cloud: The following are the key benefits of using IaC in a multi-cloud enterprise setting:

•

Consistency Across Clouds

: Enables identical deployments across AWS, Azure, and GCP.

•

Scalability

: Automates provisioning of large-scale, distributed infrastructure.

•

Auditability and Compliance

: All changes are recorded in version control.

•

Disaster Recovery

: Infrastructure can be redeployed quickly from code in case of failure.

•

Collaboration

: Teams can work on infrastructure changes like application developers.

2. Multi-Cloud Deployment Challenges

Implementing a multi-cloud strategy allows organizations to mitigate vendor lock-in, optimize workload
distribution, and improve availability. Nonetheless, overseeing infrastructure across several cloud providers
presents numerous technological and operational challenges that Infrastructure as Code (IaC) seeks to resolve.
Although Infrastructure as Code (IaC) provides standardization, automation, and repeatability, its deployment in
multi-cloud settings necessitates meticulous management of platform discrepancies, governance requirements,
and security measures.

•

Heterogeneous Cloud APIs and Services

: Every cloud provider

—

Amazon Web Services (AWS), Microsoft Azure,

and Google Cloud Platform (GCP)

—

presents distinct APIs, nomenclature, and services. These discrepancies

result in heightened complexity while endeavoring to construct reusable and portable Infrastructure as Code
components.
Provisioning a virtual machine in AWS (via EC2), Azure (via Virtual Machines), or GCP (via Compute Engine)
entails unique configuration parameters and authentication protocols. This fragmentation obstructs genuine
code portability among providers.

•

Configuration Drift: Inconsistent application of IaC tools or manual interventions in cloud consoles can lead to
a divergence between the infrastructure's real state and the specified configuration in code, a phenomenon
referred to as configuration drift. Identifying and addressing such drift across several clouds becomes
increasingly complicated as scale and diversity expand [1].

•

Secret and Credential Management: Safeguarding credentials, API tokens, and secrets across several settings
poses a significant difficulty. In the absence of centralized administration, companies jeopardize the security of
sensitive

information

and

the

adherence

to

compliance

mandates.

Secrets management should be incorporated into Infrastructure as Code workflows via cloud-native services
such as AWS Secrets Manager, Azure Key Vault, or third-party solutions like HashiCorp Vault.

•

Networking and Interoperability

: Establishing seamless interconnection across services and data across

disparate cloud infrastructures is frequently complex. Establishing cross-cloud private networks, efficiently
routing traffic, and maintaining firewalls, DNS, and identity access regulations necessitate meticulous
orchestration.
Inconsistent network models and regional availability among providers might exacerbate complexities in cross-
cloud deployment scenarios.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

177

•

Policy Enforcement and Adherence

: Organizations must implement policies pertaining to identity

management, resource tagging, cost constraints, and adherence to industry standards such SOC 2, PCI-DSS, and
HIPAA. Consistently enforcing these regulations across various cloud environments necessitates tools that
facilitate policy-as-code and integration into CI/CD pipelines.

•

Instrument and State Fragmentation

: Ensuring uniformity in toolchains and infrastructure state files across

cloud-specific and cloud-agnostic technologies (e.g., Terraform versus CloudFormation) is becoming
progressively challenging. Divergent tools can lead to disjointed workflows, diminished productivity, and
oversight gaps in governance.

Table 2

summarizes these major challenges along with their implications.

Challenge

Description

Implications

Heterogeneous APIs

Different resource definitions and
parameters across clouds

Low portability and increased
development effort

Configuration Drift

Deviation between actual and desired
infrastructure state

Risk of instability, non-compliance

Secrets Management

Multiple systems with different access
controls

Risk of credential leakage or
inconsistent policies

Networking and
Interoperability

Differences in VPCs, subnets, and routing
across providers

Increased latency, limited
interoperability

Compliance and Policy
Enforcement

Difficulty in enforcing global rules uniformly Regulatory risk and audit complexity

Tooling and State
Fragmentation

Lack of unified state management and
workflows

Inconsistent deployments, reduced
visibility

Table 2: Key Challenges in Multi-Cloud IaC Deployments

3. IaC Best Practices for Multi-Cloud

More than merely scripting capabilities are required to effectively manage multi-cloud architecture using
architecture as Code (IaC). It necessitates a strategic framework of best practices that provide consistency,
compliance, scalability, and portability across several cloud platforms. This section emphasizes the most
important principles that businesses should follow when implementing IaC in a multi-cloud environment.

3.1 Use modular and reusable code:
Infrastructure definitions should be separated down into reusable, parameterized modules to improve code
maintainability and scalability across cloud environments.

-

Terraform modules enable the abstraction and reuse of resources like as VPCs, IAM roles, and Kubernetes
clusters.

-

CloudFormation stacks and layered stacks provide similar modular designs with AWS.

This modularity improves readability, allows for uniform deployments, and reduces duplication between
environments.

3.2 Develop a unified tooling strategy.
Choosing the correct tools and staying consistent are critical. Cloud-agnostic tools like Terraform, Pulumi, and
Crossplane offer consistent provisioning across AWS, Azure, and GCP. Tools should be evaluated based on the

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

178

following:

-

Support for numerous providers.

-

Extensibility through plugins

-

Community Adoption and Maturity

-

Integration of CI/CD workflows

Figure 3

illustrates a tool selection framework across key criteria

.

Figure 3: Multi-Cloud IaC Tool Selection Framework

3.3 Manage state. Remotely and securely
Multi-cloud deployments necessitate centralized and secure state management to minimize drift and concurrency
concerns. Recommendations include:

-

Remote state can be stored using Terraform Cloud, AWS S3 with DynamoDB lock tables or Azure Storage.

-

Setting up access limits and audit logs for state backends.

3.4 Integrate Policy as Code for Governance
Enterprises must regularly implement organizational and compliance requirements. Implementing policy-as-code
technologies such as:

-

Open Policy Agent (OPA) for Kubernetes and Terraform

-

Sentinel for HashiCorp Tools

-

Azure Policy for Native Azure Governance.

These policies can enforce name conventions, tag requirements, and protect against insecure settings.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

179

3.5 Automate Deployments Using CI/CD Pipelines
IaC should be fully integrated into CI/CD pipelines to improve efficiency and dependability. Recommended stages
include:

-

Linting (e.g., tflint, CFN-lint)

-

Validation (e.g., Terraform plan, validate)

-

Security Scanning (e.g., Checkov, TFSEC)

-

Automated testing (such as Terratest)

-

Approval Workflows

-

Deployment and rollback logic

3.6 Implement Secret and Credential Management.
Here are some best practices for managing secrets across several clouds:

-

Avoid hardcoding credentials into code or configuration files.

-

Use cloud-native solutions such as AWS Secrets Manager, Azure Key Vault, and GCP Secret Manager.

-

Use tools like SOPS, Vault, or Sealed Secrets to store encrypted version-controlled secrets.

3.7 Maintain idempotency and test for drift.
Ensure that IaC scripts are idempotent, which means they can be used several times without causing unwanted
consequences. Additionally, use tools such as:

-

Terraform Drift Detection

-

Driftctl

-

Cloud Custodian

These tools are useful for detecting and correcting configuration drift across various clouds.

3.8 Implement cross-cloud tagging strategies.
Consistency in resource tagging across cloud providers improves:

-

Cost Allocation

-

Security auditing

-

Resource Lifecycle Management

Define and enforce global tag schemas with policy-as-code or pre-commit hooks.

Table 3

summarizes best practices and their tools.

Practice Area

Tool/Methodology

Modularization

Terraform modules, CloudFormation nested stacks

Unified Tooling

Terraform, Pulumi, Crossplane

Remote State Management

Terraform Cloud, S3 + DynamoDB, Azure Storage

Policy-as-Code

OPA, Sentinel, Azure Policy

CI/CD Automation

GitHub Actions, GitLab CI, Jenkins

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

180

Practice Area

Tool/Methodology

Secret Management

Vault, AWS Secrets Manager, Azure Key Vault

Drift Detection

Driftctl, Terraform plan, Cloud Custodian

Tagging Strategy

Policy enforcement, tag schemas, IaC hooks

Table 3: Summary of Best Practices for IaC in Multi-Cloud

4. Governance and Security Considerations

Governance and security are critical in multi-cloud settings. As companies scale their Infrastructure as Code (IaC)
operations, the risk surface increases, necessitating the integration of security and policy enforcement throughout
the infrastructure deployment lifecycle. This section describes essential governance and security best practices
and tools that are consistent with enterprise compliance standards and DevSecOps objectives.

4.1 Policy-as-Code for Governance

Policy-as-Code (PaC) enables organizations to define and enforce governance rules through machine-readable
policies. By embedding PaC into CI/CD pipelines, enterprises can enforce controls on naming conventions, cost
tagging, region restrictions, and resource sizing.

Recommended Tools:

-

OPA (Open Policy Agent): Works with Terraform, Kubernetes, and CI/CD workflows.

-

HashiCorp Sentinel: Offers fine-grained access and policy control integrated with Terraform Enterprise.

-

Azure Policy and AWS Config: Cloud-native solutions for enforcement and auditing.

Benefits:

-

Reduces human error and drift

-

Ensures compliance with internal and external regulations (e.g., PCI-DSS, HIPAA)

-

Blocks risky deployments proactively

4.2 Identity and Access Management (IAM)

A key challenge in multi-cloud IaC is maintaining consistent identity and access management. Misconfigured IAM
can lead to privilege escalation or data breaches.

Best Practices:

-

Implement least privilege access using roles and scopes.

-

Use federated identity providers (e.g., Azure AD, Okta) across cloud platforms.

-

Audit and rotate credentials regularly.

-

Incorporate role-based access control (RBAC) and attribute-based access control (ABAC) into your IaC
workflow.

4.3 Secure Secrets Management

IaC templates must avoid embedding sensitive information such as API keys, tokens, or SSH credentials. Use
secret management solutions integrated into your IaC lifecycle.

Tools and Methods:

-

HashiCorp Vault, AWS Secrets Manager, Azure Key Vault

-

Encrypt secrets at rest and in transit

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

181

-

Apply role-based access to secret stores

-

Use dynamic secrets where possible to reduce exposure

4.4 Version Control and Change Management

Governance requires visibility and traceability. All IaC changes should go through version-controlled repositories
and approval workflows.

-

Use GitOps workflows with PR-based approvals

-

Automate change tickets via integration with ITSM tools (e.g., ServiceNow)

-

Maintain audit logs of changes using Git, Terraform Cloud, or CI/CD logs

4.5 Drift Detection and Remediation

Configuration drift presents major governance difficulties. Integrate drift detection techniques to monitor
inconsistencies between the code and the real deployed infrastructure

Tools:

-

Terraform Plan and Refresh

-

Driftctl

-

Cloud Custodian

Table 4

provides a summary of governance and security controls with associated tools

Governance Area

Recommended Tools/Practices

Policy Enforcement

OPA, Sentinel, Azure Policy, AWS Config

IAM and Access Control

IAM roles, federated identities, RBAC, ABAC

Secrets Management

Vault, AWS Secrets Manager, SOPS, Azure Key Vault

Change Management

Git workflows, CI/CD approval gates, ITSM integration

Drift Detection

Driftctl, Terraform Plan, Cloud Custodian

Audit and Compliance

Git logs, Terraform Cloud, CI/CD logging, tagging enforcement

Table 4: Governance and Security Best Practices in Multi-Cloud IaC

5. Case Study: Financial Services Multi-Cloud IaC

5.1 Background

A worldwide financial services organization with operations in over 50 countries opted to implement a multi-cloud
strategy to increase availability, eliminate vendor lock-in, and comply with data sovereignty regulations. The
organization selected AWS for core banking APIs and Azure for internal analytics workloads. However, the absence
of a consistent infrastructure management methodology resulted in more provisioning failures, configuration drift,
and audit issues.

To address these concerns, the company built a Terraform-based Infrastructure as Code (IaC) strategy across both
cloud platforms, which was supplemented with GitOps workflows, centralized secrets management, and policy-as-
code enforcement.

5.2 Objectives

•

Automate infrastructure provisioning to reduce manual errors.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

182

•

Ensure compliance with PCI-DSS and SOC 2 controls by using auditable change tracking.

•

Standardize resource setups and networking on both AWS and Azure.

•

Enable environment replication for disaster recovery and testing workloads.

5.3 Architecture Overview

Figure 5

shows the high-level architecture of the IaC CI/CD pipeline implemented across AWS and Azure.

Figure 5: Multi-Cloud IaC Pipeline Architecture for a Financial Enterprise

5.4 Tools and Practices Implemented

Area

Implementation Details

IaC Tool

Terraform with remote state stored in Azure Blob and AWS S3

CI/CD Pipelines

GitHub Actions integrated with Terraform workflows

Secrets Management

HashiCorp Vault with role-based access for service accounts

Policy-as-Code

Open Policy Agent (OPA) to enforce tagging, encryption, and approved region usage

Audit Logging

Git logs, Vault audit trails, and Terraform Cloud run history

Drift Detection

Weekly Terraform plan runs, integrated alerts for drift via Slack channels

Table 5: Tools used with Governance Area

5.5. Outcomes and Metrics

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

183

The transition to IaC-based multi-cloud provisioning yielded measurable improvements:

•

65% reduction

in time-to-deploy infrastructure across development, staging, and production.

•

100% coverage

for compliance tagging and encryption enforcement via OPA.

•

90% decrease

in configuration drift incidents over a six-month period.

•

Enhanced audit readiness

, meeting annual PCI-DSS and internal compliance reviews.

Table 6

presents a summary of pre- and post-IaC implementation metrics.

Metric

Before IaC

After IaC

Provisioning Time

3

–

5 days

< 1 day

Drift Incidents

~15/month

< 2/month

Compliance Enforcement Coverage

Partial (manual reviews)

Automated, > 95%

Audit Log Availability

Fragmented logs

Centralized and versioned

Team Collaboration

Isolated changes

PR-based GitOps workflows

Table 6: Impact of IaC Implementation in Financial Services Firm

5.6 Lessons Learned

•

Modularization is Important: Using reusable Terraform modules helped keep DRY (Don't Repeat Yourself)
principles across cloud providers.

•

Toolchain Unification: Using provider-agnostic tools alleviated the effort of managing cloud-native
templates.

•

Security from the Start: Integrating Vault and OPA early prevented last-minute compliance retrofitting.

•

Cross-Team Enablement: GitOps improved openness and facilitated infrastructure contributions from both
DevOps and security teams.

6. Future Trends

As enterprises continue to scale their cloud adoption and demand greater agility, the future of Infrastructure as
Code (IaC) will be shaped by advancements in automation, intelligence, and policy governance. The following
emerging trends are expected to influence multi-cloud IaC implementations significantly in the coming years:

6.1 AI-Driven IaC Automation

Artificial Intelligence (AI) and Machine Learning (ML) are progressively utilized in Infrastructure as Code (IaC)
operations. These technologies are capable of:

•

Examine infrastructure code to anticipate faults or deviations.

•

Advise on best configurations derived from previous deployments

•

Automate standard code evaluations via trained LLMs (Large Language Models).

AI copilots, such as GitHub Copilot, are now assisting DevOps engineers in the expedited and precise writing and
reviewing of Terraform modules [2].

6.2 Policy-as-Code as a Service (PaaS)

The demand for centralized and scalable governance structures is increasing due to rising regulatory complexity.

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

184

Platforms offering "Policy-as-Code as a Service" are anticipated to arise, enabling companies to:

•

Acquire policy packs that adhere to industry regulations (e.g., HIPAA, GDPR)

•

Utilize APIs to authenticate infrastructure plans in real-time.

•

Facilitate collaborative policy governance among cloud service providers

This tendency facilitates proactive compliance and reduces the manual load of audits [3].

6.3 Infrastructure Drift Remediation Automation

Currently, many drift detection tools notify users of state mismatches but still require manual intervention to
remediate. Future solutions will:

•

Automatically reconcile differences between code and deployed infrastructure

•

Allow safe auto-remediation workflows with customizable thresholds

•

Use ML-based anomaly detection to trigger remediations only when risk is high

6.4 Standardization of Multi-Cloud IaC Modules

The community is progressing towards standardized Infrastructure as Code modules compatible with AWS, Azure,
and GCP. Initiatives such as:

•

Cloud Development Kit for Terraform (CDKTF)

•

Crossplane

•

OpenTofu (a fork of Terraform)

Strive to diminish provider-specific intricacy and enhance developer experience in diverse cloud settings [4].

6.5 Integrated Security Scanning and Attestation

Security will be progressively integrated into IaC operations via automated attestation frameworks. These will check
not just the structure of the infrastructure, but also its compliance, security posture, and runtime behavior prior to
execution.

•

Tools such as Checkov, tfsec, and Bridgecrew are expanding to add runtime attestation.

•

Integration with SBOMs (Software Bill of Materials) for infrastructure components will become the norm in
regulated industries.

6.6 Event-Driven Infrastructure (EDI)

IaC will evolve to support more dynamic, real-time provisioning based on events such as:

•

Spike in traffic (auto-provisioning a new load balancer)

•

Deployment of a new microservice

•

Changes in compliance status

This is enabled by infrastructure orchestrators that integrate deeply with

event buses

(e.g., AWS EventBridge,

Google Eventarc).

Table 7

provides a summary of these future trends and their implications

AMERICAN ACADEMIC PUBLISHER

https://www.academicpublishers.org/journals/index.php/ijns

185

Trend

Description

Implication

AI-Driven Automation

ML for code analysis, optimization,
drift prediction

Reduces manual effort and improves
code quality

Policy-as-Code as a
Service

Externalized governance platforms

Ensures real-time compliance across
clouds

Automated Drift
Remediation

Self-healing infrastructure via IaC

Enhances uptime and reduces
operational overhead

Standard IaC Modules

Reusable, cross-provider templates

Boosts developer productivity and
portability

Security Attestation
Integration

Runtime validation of infrastructure
plans

Ensures zero-trust deployment
workflows

Event-Driven
Infrastructure

Auto-deployment based on real-time
signals

Supports responsive, dynamic scaling
and governance

Table 7: Emerging Trends in Multi-Cloud IaC

7. CONCLUSION

As organizations expedite their digital transformation efforts, Infrastructure as Code (IaC) becomes a pivotal
facilitator for overseeing scalable, robust, and compliant infrastructure across multi-cloud settings. By integrating
infrastructure management with software development principles, Infrastructure as Code (IaC) promotes
automation,

consistency,

and

version-controlled

governance.

This article delineates the fundamental principles of Infrastructure as Code (IaC), the distinct issues associated with
deployment across various cloud providers, and the optimal approaches to alleviate complexity and maintain
consistency. Essential factors include tool standardization, modular design, policy-as-code enforcement, secure
secrets management, and drift detection are pivotal in developing advanced, enterprise-level Infrastructure as Code
practices.

We have illustrated, through a real-world case study in the financial services sector, that effective use of
Infrastructure as Code (IaC) not only optimizes deployment times but also enhances regulatory compliance and
operational robustness. Furthermore, the advent of AI-driven automation, event-triggered infrastructure, and
standardized modules indicates a future in which Infrastructure as Code (IaC) transcends its role as a mere tool and
becomes

a

fundamental

component

of

enterprise

infrastructure

strategy.

As enterprises increasingly adopt multi-cloud architectures, Infrastructure as Code (IaC) will persist as a
fundamental component of DevOps maturity, facilitating accelerated innovation while mitigating risk through
codified governance, automation, and auditability. Organizations that emphasize strong Infrastructure as Code
frameworks will be optimally equipped to manage the intricacies and expansion of future digital environments.

REFERENCES

1.

Sato, H., Ueda, Y., & Nakagawa, H. (2022).

Configuration Drift Detection in IaC for Multi-Cloud Systems

. IEEE

Transactions on Cloud Computing.