Infrastructure as Code (IaC)
What is Infrastructure as Code (IaC)?
Overview
Infrastructure as Code (IaC) is the managing and provisioning of infrastructure through code instead of through manual processes.
Wikipedia defines IaC as follows:
Infrastructure as code is the process of managing and provisioning computer data centers through machine-readable definition files, rather than physical hardware configuration or interactive configuration tools.
Infrastructure as code (IaC) means to manage your IT infrastructure using configuration files.
IaC is the process of provisioning and managing infrastructure defined through code, instead of doing so with a manual process.
As infrastructure is defined as code, it allows users to easily edit and distribute configurations while ensuring the desired state of the infrastructure. This means you can create reproducible infrastructure configurations.
Moreover, defining infrastructure as code also:
· Allows infrastructure to be easily integrated into version control mechanisms to create trackable and auditable infrastructure changes.
· Provides the ability to introduce extensive automation for infrastructure management. All these things lead to IaC being integrated into CI/CD pipelines as an integral part of the SDLC.
· Eliminates the need for manual infrastructure provisioning and management. Thus, it allows users to easily manage the inevitable config drift of underlying infrastructure and configurations and keep all the environments within the defined configuration.
With IaC, configuration files are created that contain your infrastructure specifications, which makes it easier to edit and distribute configurations. It 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.
Version control is an important part of IaC, and your configuration files should be under source control just like any other software source code file.
Deploying your infrastructure as code also means that you can divide your infrastructure into modular components that can then be combined in different ways through automation.
Automating infrastructure provisioning with IaC means that developers don’t need to manually provision and manage servers, operating systems, storage, and other infrastructure components each time they develop or deploy an application. Codifying your infrastructure gives you a template to follow for provisioning, and although this can still be accomplished manually, an automation tool, such as Red Hat® Ansible® Automation Platform, can do it for you.
Infrastructure as code is sometimes referred to as programmable or software-defined infrastructure.
The concept of infrastructure as code is similar to programming scripts, which are used to automate IT processes. However, scripts are primarily used to automate a series of static steps that are repeated numerous times across multiple servers. Infrastructure as code uses higher-level or descriptive language to code more versatile and adaptive provisioning and deployment processes.
For example, infrastructure-as-code capabilities included with Ansible, an IT management and configuration tool, can install MySQL server, verify that MySQL is running properly, create a user account and password, set up a new database and remove unneeded databases.
The code-based infrastructure automation process closely resembles software design practices in which development teams carefully control code versions, test iterations and limit deployment until the software is proven and approved for production.
Declarative vs. imperative approaches to IaC
Infrastructure as code and cloud computing
Benefits of infrastructure as code
Immutable vs. mutable infrastructure
Infrastructure as Code tools & platforms
Examples of Infrastructure as Code
Why does IaC matter for DevOps?
When & how to use Infrastructure as Code
A real world example: IaC for DevOps
Importantly, IaC is not a derivative of infrastructure as a service (IaaS). They are two different concepts.
· Infrastructure as a Service is one of the core cloud services: virtualized computing resources—servers, networking infrastructure, storage, etc.—are provided via the cloud service.
· Infrastructure as Code is a tool that can be used to provision and manage infrastructure. It is not limited to only cloud-based resources. In fact, you apply IaC to a wide variety of environments, including on-premises.
Declarative vs. imperative approaches to IaC
There are 2 ways to approach IaC: declarative or imperative.
A declarative approach
A declarative approach, on the other hand, “declares” the desired outcome. Instead of explicitly outlining the sequence of steps the infrastructure needs to reach the final result, the declarative approach shows what the final result looks like.
It defines the desired state of the system, including what resources you need and any properties they should have, and an IaC tool will configure it for you.
A declarative approach also keeps a list of the current state of your system objects, which makes taking down the infrastructure simpler to manage.
A declarative programming approach outlines the desired, intended state of the infrastructure, but does not explicitly list the steps to reach that state. SQL is a commonly known declarative programming language. AWS CloudFormation templates, among others, are written in the declarative style of infrastructure as code.
An imperative approach
The imperative approach “gives orders.” It defines a sequence of commands or instructions so the infrastructure can reach the final result.
instead defines the specific commands needed to achieve the desired configuration, and those commands then need to be executed in the correct order.
Many IaC tools use a declarative approach and will automatically provision the desired infrastructure. If you make changes to the desired state, a declarative IaC tool will apply those changes for you. An imperative tool will require you to figure out how those changes should be applied.
In contrast, an imperative approach defines commands that enable the infrastructure to reach the desired state. Object-oriented languages, such as C++ and Java, can be used for imperative programming. A tool such as Chef can be used in the declarative manner, but also imperatively as needed.
In both approaches, infrastructure as code is configured on a template, where the user specifies the resources needed for each server in the infrastructure. The template is used to either verify that a system is properly configured or put it in the appropriate setup. Templates can be constructed as a set of layers of resources, such as in AWS CloudFormation, which makes a stack.
Chef is considered an imperative tool, where Terraform, Pulumi, CloudFormation, ART, Puppet are all declarative. Uniquely, Ansible is mostly declarative with support for imperative commands.
IaC tools are often able to operate in both approaches, but tend to prefer one approach over the other.
Simply put:
· An imperative approach allows users to specify the exact steps to be taken for a change, and the system does not deviate from the specified steps.
· A declarative approach essentially means users only need to define the end requirement, and the specific tool or platform handles the steps to take in order to achieve the defined requirement.
Infrastructure as Code Saves You Time and Money
Infrastructure as code is a crucial part of the DevOps movement. If you think of cloud computing as the first step to solving many of the problems caused by manual IT management, then it’s fair to say the IaC is the next logical step. It takes cloud computing to its fullest potential, and it frees developers and other professionals from performing manual, error-prone tasks. Plus, it lowers costs and improves efficiency at all stages of the software development lifecycle. Besides IaC, it also helps to have a tool like Retrace. Retrace is a code-level APM solution that can manage and monitor your app’s performance throughout the entire development lifecycle. Plus, it offers many other features, such as error tracking, log management, and application metrics. Start your trial today.
Infrastructure as code and cloud computing
IaC predefined sets of instructions:
· Provision resources.
· Configure the instance.
· Configure and deploy a workload into the instance.
· Connect associated services.
· Monitor and manage the deployment over time.
This depth of automation is especially important because of the cloud's vast array of applications, services and functions, stacked together and mainly connected through APIs. The scale and scope of cloud requires an automated governed process, rather than doing everything manually. Organizations with hybrid cloud benefit even more, as such templated configurations and resources can be applied across multiple environments.
Benefits of infrastructure as code
Now infrastructure management has moved away from physical hardware in data centers, though this still may be a component for your organization, to virtualization, containers, and cloud computing.
IaC can help your organization manage IT infrastructure needs while also improving consistency and reducing errors and manual configuration.
Benefits:
· Cost reduction
· Increase in speed of deployments
· Reduce errors
· Improve infrastructure consistency
· Eliminate configuration drift
More benefits of IaC:
· Reducing shadow IT within organizations and allowing timely and efficient infrastructure changes that are done in parallel to application development.
· Integrating directly with CI/CD platforms.
· Enabling version-controlled infrastructure and configuration changes leading to trackable and auditable configurations.
· Easily standardizing infrastructure with reproducible configurations.
· Effectively managing configurating drift and keeping infrastructure and configurations in their desired state.
· Having the ability to easily scale up infrastructure management without increasing CapEx or OpEx. With IaC, you’ll reduce CapEx and OpEx spending overall, as automation eliminates the need for time-consuming manual interactions and reduces incorrect configurations.
1, Speed
The first significant benefit IaC provides is speed. Infrastructure as code enables you to quickly set up your complete infrastructure by running a script. You can do that for every environment, from development to production, passing through staging, QA, and more. IaC can make the entire software development lifecycle more efficient.
Speed and efficiency.
- Automated provisioning and management are faster and more efficient than manual processes. This stretches not just to provisioned resources and virtualization, but also to databases, networking, user account management and other tied-in services. IaC also can include code that automatically scales (adds or shuts down environments and resources when they are no longer needed).
2. Consistency
Manual processes result in mistakes, period. Humans are fallible. Our memories fault us. Communication is hard, and we are in general pretty bad at it. As you’ve read, manual infrastructure management will result in discrepancies, no matter how hard you try. IaC solves that problem by having the config files themselves be the single source of truth. That way, you guarantee the same configurations will be deployed over and over, without discrepancies.
- Software developers can use code to provision and deploy servers and applications according to business practices and policies, rather than rely on system administrators in a DevOps environment. A developer might create a configuration file to provision and deploy a new application for quality assurance or experimental deployment before operations takes over for live deployment in production.
3. Accountability
This one is quick and easy. Since you can version IaC configuration files like any source code file, you have full traceability of the changes each configuration suffered. No more guessing games about who did what and when.
4. More Efficiency During the Whole Software Development Cycle
By employing infrastructure as code, you can deploy your infrastructure architectures in many stages. That makes the whole software development lif cycle more efficient, raising the team’s productivity to new levels.
You could have programmers using IaC to create and launch sandbox environments, allowing them to develop in isolation safely. The same would be true for QA professionals, who can have perfect copies of the production environments in which to run their tests. Finally, when it’s deployment time, you can push both infrastructure and code to production in one step.
5. Lower Cost
One of the main benefits of IaC is, without a doubt, lowering the costs of infrastructure management. By employing cloud computing along with IaC, you dramatically reduce your costs. That’s because you won’t have to spend money on hardware, hire people to operate it, and build or rent physical space to store it. But IaC also lowers your costs in another, subtler way, and that is what we call “opportunity cost.”
You see, every time you have smart, high-paid professionals performing tasks that you could automate, you’re wasting money. All of their focus should be on tasks that bring more value to the organization. And that’s where automation strategies—infrastructure as code among them—come in handy. By employing them, you free engineers from performing manual, slow, error-prone tasks so they can focus on what matters the most.
Alignment with DevOps.
- With the infrastructure setup written as code, it can go through the same version control, automated testing and other steps of a continuous integration and continuous delivery (CI/CD) pipeline that developers use for application code. An organization may choose to combine infrastructure as code with containers, which abstract the application from the infrastructure at the operating system level. Because the OS and hardware infrastructure are provisioned automatically and the application is encapsulated atop it, these technologies prove complementary for diverse deployment targets, such as test, staging and production.
Infrastructure as code allows IT teams to translate into code a data center's physical resources and services and discrete configurations, so they can automatically provision and manage those resources.
Despite its benefits, infrastructure as code poses potential disadvantages. It requires additional tools, such as a configuration management and automation/orchestration system, that could introduce learning curves and room for error. Any errors can proliferate quickly through servers, especially where there is extensive automation, so it is essential to monitor version control and perform comprehensive prerelease testing.
If administrators change server configurations outside of the set infrastructure-as-code template, there is potential for configuration drift without the use of additional change management tools. It's important to fully integrate infrastructure as code into systems administration, IT operations and DevOps practices with well-documented policies and procedures. If legacy security and monitoring tools are not up to the task to handle infrastructure as code, this will require additional investments in more tools, with additional training and testing to integrate them into workflows.
Another challenge with infrastructure as code is that it places more responsibility onto developers to understand how to write efficient code that translates seamlessly into production environments. They must also have strong knowledge of languages used for infrastructure as code however an organization has implemented it, such as JSON, YAML, Ruby, C++ or SQL.
Immutable vs. mutable infrastructure
Mutable infrastructure refers to the practice whereby infrastructure components are changed in production, while the overall service or application continues to operate as normal. Immutable infrastructure assembles and sets components and resources to create a full service or application. If a change is required for any component, they are not changed or reconfigured -- they are all updated and effectively redeployed in an instance. A new iteration is assembled, tested, validated and launched, while the old iteration is discontinued and its resources released for reuse.
Immutable infrastructure has gained favor particularly for cloud and microservices environments, which are highly scalable and involve many more interdependent components and services. Any one-off updates to address specific issues can cause configuration drift that cascades as updates are rapidly pushed to production.
It's more efficient and effective to reissue sets of immutable services and components than to patch and reconfigure individual infrastructure components.
Infrastructure as Code tools & platforms
Under the big IaC umbrella, there are all sorts of tools, from dedicated infrastructure management tools to configuration management, from open-source tools to platform-specific IaC options.
These are a few popular choices:
· Chef
· Puppet
· Red Hat Ansible Automation Platform
· Saltstack
· AWS CloudFormation
Ansible Automation Platform can be used to provision operating systems and network devices, deploy applications, and manage configuration.
Infrastructure-as-code tools configure and automate the provisioning of infrastructure. These tools can automatically execute the deployment of infrastructure, such as servers, with orchestration functionality. They also can configure and monitor previously provisioned systems.
Infrastructure-as-code tools enforce the setup from the template via push or pull methods. In the push method, a centralized server sends the desired configuration to a specific system or systems. The pull method is initiated by a request to a centralized server from a system or systems in the infrastructure. Tools typically are designed by default for push or pull deployment of code, but can be set up for specific instances to do the other.
Examples of infrastructure-as-code tools include AWS CloudFormation, Red Hat Ansible, Chef, Puppet, SaltStack and HashiCorp Terraform. Some tools rely on a domain-specific language (DSL), while others use a standard template format, such as YAML and JSON.
When selecting a tool, organizations should consider the target deployment. For example, AWS CloudFormation is designed to provision and manage infrastructure on AWS, and it works with other AWS offerings.
· Stephen J. Bigelow, Infrastructure-as-Code-IAC
Terraform
Terraform by HashiCorp is the leading IaC tool specialized in managing infrastructure across various platforms from AWS, Azure, GCP to Oracle Cloud, Alibaba Cloud, and even platforms like Kubernetes and Heroku.
As a platform-agnostic tool, Terraform can be used to facilitate any infrastructure provisioning and management use cases across different platforms and providers while ensuring the desired state across the configurations.
Ansible
Ansible is not a dedicated Infrastructure management tool but more of an open-source configuration management tool with IaC capabilities. Ansible supports both cloud and on-prem environments and can act through SSH or WinRM as an agentless tool. Ansible excels at configuration management and infrastructure provisioning yet is limited when it comes to managing said infrastructure.
Pulumi
Pulumi is a relatively new tool that aims to provide a developer-first IaC experience. Unlike other tools that force users to use a specific language or format, Pulumi offers freedom to use any supported programming language any way they like. This tool supports Python, TypeScript, JavaScript, Go, C#, F#, and the state is managed through Pulumi service by default.
Chef/Puppet
Chef and Puppet are two powerful configuration management tools. Both aim to provide configuration management and automation capabilities with some infrastructure management capabilities across the development pipeline.
· Chef is developed to be easily integrated into DevOps practices with greater collaboration tools.
· Puppet evolved by targeting sheer processes automation. Today, Puppet has automated built-in watchers to identify configuration drift.
CFEngine
CFEngine is one of the most mature tools solely focused on configuration management. Even though there is no capability to manage the underlying infrastructure, CDEngine can accommodate even the most complex configuration requirements, covering everything from security hardening to compliance.
AWS CloudFormation
CloudFormation is the AWS proprietary platform specific IaC tool to manage AWS infrastructure. CloudFormation has deep integration with all AWS services and can facilitate any AWS configuration as a first-party solution.
Azure Resource Templates
Microsoft Azure uses JSON-based Azure Resource Templates to facilitate IaC practices within the Azure platform. These resource templates ensure consistency of the infrastructure and can be used for any type of resource configuration.
In addition to the above, there are specialized tools aimed at specific infrastructure and configuration management tasks such as:
· Packer, EC2 Image Builder, and Azure Image Builder create deployable custom os images.
· Cloud-Init is the industry-standard cross-platform cloud instance initialization tool. It enables users to execute the script when provisioning resources (servers).
· (R)?ex is a fully featured infrastructure automation framework
Examples of Infrastructure as Code
Let’s consider a simple scenario of provisioning an AWS EC2 Instance. In the following example, we can see how Terraform, Ansible, and AWS CloudFormation codes are used for this requirement.
Terraform
Copy
terraform {
required_providers{
aws={
source ="hashicorp/aws"
version ="~> 3.27"
}
}
}
provider "aws"{
access_key="aws_access_key"
secret_key="aws_secret_key"
// shared_credentials_file = "/Users/.aws/creds"
region ="us-west-1"
}
resource "aws_instance""web_server"{
ami="ami-0123456"
instance_type="t3.small"
subnet_id="subnet-a000111x"
vpc_security_group_ids="sg-dfdd00011"
key_name="web_server_test_key"
tags ={
Name="Web_Server"
}
}
Ansible
Copy
- hosts: localhost
gather_facts:False
vars_files:
-credentials.yml
tasks:
- name:Provision EC2 Instance
ec2:
aws_access_key:"{{aws_access_key}}"
aws_secret_key:"{{aws_secret_key}}"
key_name:web_server_test_key
group: test
instance_type: t3.small
image:"ami-0123456"
wait:true
count:1
region: us-west-1
instance_tags:
Name:Web_Server
register: ec2
AWS CloudFormation
Copy
AWSTemplateFormatVersion:"2010-09-09"
Resources:
WebInstance:
Type:AWS::EC2::Instance
Properties:
InstanceType: t3.small
ImageId: ami-0123456
KeyName:web_server_test_key
SecurityGroupIds:
- sg-dfdd00011
SubnetId: subnet-a000111x
Tags:
-
Key:Name
Value:Web_Server
Why does IaC matter for DevOps?
IaC is an important part of implementing DevOps practices and continuous integration/continuous delivery (CI/CD). IaC takes away the majority of provisioning work from developers, who can execute a script to have their infrastructure ready to go.
That way, application deployments aren’t held up waiting for the infrastructure, and sysadmins aren’t managing time-consuming manual processes.
CI/CD relies on ongoing automation and continuous monitoring throughout the application life cycle, from integration and testing to delivery and deployment.
Automating application deployments doesn’t work when the development team deploys applications or configures environments one way and the operations teams deploys and configures another way.
Aligning development and operations teams through a DevOps approach leads to fewer errors, manual deployments, and inconsistencies.
IaC helps you to align development and operations because both teams can use the same description of the application deployment, supporting a DevOps approach.
The same deployment process should be used for every environment, including your production environment. IaC generates the same environment every time it is used.
IaC also removes the need to maintain individual deployment environments with unique configurations that can’t be reproduced automatically and ensures that the production environment will be consistent.
DevOps best practices are also applied to infrastructure in IaC. Infrastructure can go through the same CI/CD pipeline as an application does during software development, applying the same testing and version control to the infrastructure code.
Why choose Red Hat for automation?
Creating an enterprise-wide approach to automation lets you automate not only IT processes, but also entire technologies, teams, and organizations.
Red Hat® Ansible® Automation Platform includes all the tools needed to implement enterprise-wide automation, including playbooks, a visual dashboard, and analytics. It also uses webhooks to automate IaC workflows and enable GitOps practices.
Ansible Playbooks, written in YAML, describe the desired state of your systems, which are usually kept in source control. Ansible Automation Platform does the work of getting your systems to the desired state, no matter their current state.
Ansible Automation Platform makes your installations, upgrades and day-to-day management repeatable and reliable.
With an Ansible Automation Platform subscription, you can deploy new applications and services faster, manage IT infrastructure more efficiently, and see an increase in app development productivity.
· Make code your single source of truth. You should explicitly code all the infrastructure specifications in configuration files. Your configuration files should be the single source of truth for all your infrastructure management concerns.
· Version control all of your configuration files. This probably should go without saying, but put all of your config files under source control.
· Use little documentation (or none at all) for your infrastructure specifications. This point is the logical consequence of the first one. Since your config files should be your single source of truth, there should be no need for more documentation. External documentation can easily get out of sync with the real configurations, but that won’t happen with the config files.
· Test and Monitor Your Configurations. IaC is code, and like all code, it can be tested. So test it you should! By employing testing and monitoring tools for IaC, you can check for errors and inconsistencies in your servers before you deploy them to production.
Carlos Schults DEVELOPER TIPS, TRICKS & RESOURCES What-is-infrastructure-as-code-how-it-works-best-practices-tutorials
What Problem Does IaC Solve?
The Pain of Managing IT Infrastructure
Historically, managing IT infrastructure was a manual process. Unsurprisingly, this manual process would often result in several problems.
The first big problem is cost.
You’d have to hire many professionals to perform the necessary tasks at each step of the process, from network engineers to hardware maintenance technicians. All of those people need to be paid, obviously, but they also need to be managed. That leads to more management overhead and adds more complexity to communication inside the organization. The result? Dollars go away. And we didn’t even mention building and maintaining your own data centers, which would increase the costs by orders of magnitude.
The next big problems are scalability and availability.
But in the end, it all comes down to speed. Since manual configuration is so slow, applications would often struggle with spikes in access, while the system administrators would be desperately trying to set up servers to manage the load. This necessarily impacts availability. If the organization didn’t have backup servers or even data centers, then the application could be unavailable for long periods.
A third major problem is monitoring and performance visibility.
Now that you have all of the infrastructure in place, how do you keep an eye on it to ensure it’s performing optimally? When you have an issue, how do you pinpoint exactly where in the infrastructure the issue is coming from? Is it the network, the server, or the application? Tools like Netreo give you full visibility into the performance of your entire IT infrastructure. With Netreo’s automatic device discovery and configuration, you can ensure you won’t have any blind spots in your environment, and the platform’s topology mapping, event correlation, and automated root-cause analysis allow you to pinpoint exactly where an issue occurred.
Last but not least on our list of problems comes inconsistency.
If you have several people manually deploying configurations, discrepancies aren’t going to be unavoidable.
When & how to use Infrastructure as Code
The below table shows a categorization of the tools mentioned above according to their ideal use cases.
USE CASE |
TOOLS TO USE |
Infrastructure management |
Terraform, Pulumi, AWS CloudFormation, Azure Resource Templates |
Configuration management with somewhat limited infrastructure management capabilities |
Ansible, Chef, Puppet |
Configuration management |
CFEngine |
One tool may not be sufficient in most scenarios. For instance, Terraform may be excellent for managing infrastructure across multiple cloud environments yet may be limited when in-depth configurations are required. In those kinds of situations, users can utilize a tool such as Ansible to carry out the necessary configurations.
Likewise, users can mix and match any IaC tool and use them in their CI/CD pipelines depending on the exact requirements.
A real world example: IaC for DevOps
In the past, software delivery would follow this sort of pattern:
1. A System Administrator would setup up a physical server and install the operating system with all necessary service packs and tuning to mirror the status of the main operating live machine that supports the production environment.
2. Then a Database Administrator would undergo the same process for the support database, and the machine would be handed off to a test team.
3. The developer would deliver the code/program by copying it to the test machine, and the test team would run several operational and compliance tests.
4. Once the new code has gone through the entire process, you can deploy it to the live, operational environment. In many cases, the new code won’t work correctly, so additional troubleshooting and rework are necessary.
Manual recreation of a live environment leaves doors open to a multitude of most likely minor but potentially quite important human errors, regarding:
· OS version
· Patch level
· Time zone
· Etc.
A live environment clone, created using the exact same IaC as the live environment, has the absolute guarantee that that if it works in the cloned environment it will work in live.
To summarize:
In the past, several man-hours and human resources were required to complete the software deployment cycle (Developers, Systems Administrators, Database Administrators, Operation testers). Now, it is possible to have the developer alone complete all tasks:
1. The developer writes the application code and the configuration management-related instructions that will trigger actions from the virtualization environment, and other environments such as the database, appliances, testing tools, delivery tools, and more.
2. Upon new code delivery, the configuration management instructions will automatically create a new virtual test environment with an application server plus database instance that exactly mirrors the live operational environment structure, both in terms of service packs and versioning as well as live data that is transferred to such virtual test environment. (This is the Infrastructure as Code part of the process.)
3. Then a set of tools will perform necessary compliance tests and error identification and resolution. The new code is then ready for deployment to the live IT environment.
Infrastructure as Code has become a vital part of modern application development and deployment pipelines. It is achieved by facilitating quick and trackable infrastructure changes that directly integrate into CI/CD platforms. Infrastructure as Code is crucial for both:
· Facilitating scalable infrastructure management
· Efficiently managing the config drift in all environments
Shanika Wickramasinghe, Dan Merron Learn more about BMC › Infrastructure-as-code
Disclaimer: Some of the contents of this website have been
taken from various sources on the internet. If you find any content that should
be removed from this site because of Copyrights, please send a message and it
will be promptly removed.
|
|
|
|
|
|
Home/ Info/ Products/ BIG TECH Metaverse Metaverse Vs. Virtual Reality PC Buyers Guide/ IEEE 802 Standards Social Media Platforms Technology Videos/ Computer & IT Certifications Processor Generations Memory DDR3 Vs. DDR4 SSD Vs. HDD SAS vs. SATA HTML 5G Android Tips and Tricks STEM Business Intelligence Tools Web Intelligence Quantum Computing Artificial Intelligence (AI) Robotics Internet of Things (IOT) Web Of Things (WoT) Renewable Energy Nano Technology Cleantech Windows Run Commands Hiren's Boot CD Android Vs. IOS Mac Vs. PC Mac Keyboard Shortcuts Linux CLi Commands Venus Project/ Computer Security and Law Techno Lingo Encyclopedias Search Engines Glossary Online Jobs Contact
Active Components Passive Components Test Electrical Components Electronics Classification
AWS Certification Google Certification Oracle Certifications cisco certifications Huawei Certification Microsoft Certifications Linux Certification Business Certifications
Google-Cloud-Platform-Guide Amazon-Web-Services-Guide Global-Cloud-Infrastructure-Of-AWS Amazon-Web-Services-Cli-Guide AWS-Cloudformation Devops Microsoft-Azure Oracle-Cloud Digitalocean-Cloud Openstack-Cloud Security Topics
Certified Enterprise Blockchain Professional (CEBP) Web 3.0 Satoshi Nakamoto Cryptocurrency Dark Web Ethereum NFT Merkle Tree El-Salvador eNaira Challenges Of Crypto To Cash
Web C++ JAVA Python Python Glossary Angular.js Scala
Copyright BICT Solutions Privacy Policy. | Terms and Conditions apply | All rights reserved.