Why You Need to Stop Writing Bash and Start Using IaC 

Sam

Hello everyone! If you work with technology, especially managing computer servers or cloud services, you probably know Bash. Bash scripts are like simple instruction lists for your computer. They tell it to do things step-by-step: install software, copy files, start a program.

For a long time, Bash was the main way to automate tasks. But today, there’s a better way for managing your infrastructure (your servers, networks, databases). It’s called Infrastructure as Code (IaC).

Let’s see why IaC is often better than Bash and when Bash is still useful.

What is Bash Scripting?

Imagine you have a new computer server. You need to:

  1. Install a web server (like Nginx).
  2. Open port 80 for web traffic.
  3. Copy your website files to the server.
  4. Start the web server.

You can write a Bash script like this:

bash
#!/bin/bash
sudo apt-get update           # Update software list
sudo apt-get install -y nginx # Install Nginx
sudo ufw allow 80/tcp         # Open port 80
sudo cp -r /path/to/your/website /var/www/html/ # Copy website files
sudo systemctl start nginx    # Start Nginx
sudo systemctl enable nginx   # Make Nginx start on boot

✅ Where Bash is Strong:

  • Simplicity: It’s easy to write quick scripts for small, one-time jobs.
  • Ubiquity: Bash runs on almost all Linux-based systems without needing extra tools.
  • Flexibility: It can handle almost any task on a server.

❌ Where Bash Fails for Infrastructure:

  • State Blindness: If you run the script a second time, it doesn’t know if Nginx is already installed. It just tries to repeat the steps, which can cause errors or waste time.
  • No Rollback: If the script breaks something halfway through, it’s very hard to reliably “undo” or reverse the changes.
  • Cloud Complexity: Managing all the interconnected resources in the cloud (servers, load balancers, firewalls, and storage) becomes extremely difficult to track and manage using sequential Bash scripts.

The Power of Infrastructure as Code (IaC)

IaC tools like Terraform, Ansible, and Pulumi change the game. Instead of giving steps, you write a file that describes the final state of your infrastructure.

Here is a simplified idea of what IaC looks like (using Terraform): Terraform

Define what the server SHOULD look like
resource "aws_instance" "web_server" {
  ami           = "ami-0abcdef1234567890" 
  instance_type = "t2.micro"
  tags = {
    Name = "ProductionWebServer"
  }
}
Define what the network SHOULD look like
resource "aws_security_group" "web_sg" {
  name        = "http_access"
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

When you tell the IaC tool to “apply” this code, it handles the complexity:

  • Reads the Code: Understands your desired state (a server with a specific firewall rule).
  • Checks Reality: Compares your code to the current setup in the cloud.
  • Creates a Plan: Calculates only the necessary changes (e.g., “I need to create the server, and then add the firewall rule”).
  • Executes: Safely applies the plan.

✅ Key Benefits of IaC:

  • Desired State: It manages the difference between what you have and what you want. Running the same code twice won’t break anything—it only fixes what’s out of compliance.
  • Version Control: Your entire infrastructure is stored in Git. This means you have a full history of every change and can easily roll back to a stable version.
  • Reproducibility: You can create identical environments (Dev, Test, Prod) using the exact same code, eliminating configuration drift.
  • Collaboration: Teams can safely work on the same infrastructure definition at the same time.

When to Keep Bash in Your Toolbelt

IaC is the rule for infrastructure, but Bash is still essential for smaller tasks.

⭐ Use Bash for:

  • Small, Local Tasks: Quick cleanup, utility scripts, or tasks only on your local workstation.
  • Ad-Hoc Fixes: If you need to quickly check or fix a temporary issue on a single server.
  • Bootstrapping (The IaC Helper): IaC tools often use a small Bash script to run final configuration steps inside a new server after the IaC tool has finished creating it.

🛑 Avoid Bash for:

  • Creating, Modifying, or Deleting cloud resources (servers, databases, networks).
  • Setting up long-term software configuration across many machines.
  • Any task that is managed by your entire team.

Conclusion

For modern, scalable infrastructure, Infrastructure as Code is the mandatory best practice. It brings testing, version control, and reliability—the foundations of software development—to your operations team.

Stop giving your infrastructure a list of steps (Bash). Start giving it a detailed blueprint (IaC).

Start exploring tools like Terraform or Ansible today!

You should also read: