There was a time when building a Linux server meant following a document. Not running a script. Not applying a Terraform plan. A document. I had a few of them.

Guides I’d written or adapted over time, usually based on something I’d learned, something that had worked once, and then kept working. One of them was for building a Red Hat Enterprise Linux 7 server.

From the document:

“only install what is needed… minimal selection”

That was the starting point. A minimal install. No assumptions. No unnecessary packages. From there, the build expanded into something more structured.

Not just an installation. A baseline. Filesystems were defined up front.

  • /boot, /, /var, /home
  • LVM for flexibility
  • XFS as the default filesystem

Packages were added deliberately. Not everything. Just what we needed:

  • troubleshooting tools
  • monitoring agents
  • utilities that made the system usable

Networking was standardised.

  • static IP configuration
  • hostname management
  • consistent interface setup

Sometimes even disabling default tools if they got in the way:

“Disable NetworkManager… because it overwrites /etc/resolv.conf”

Monitoring was built in.

  • SNMP.
  • Nagios.

Not as an afterthought, but as part of the build. Security was layered on top.

  • SSH hardened.
  • Kernel parameters adjusted.
  • Unnecessary modules disabled.

And then there were the extras.

  • Postfix for alerting.
  • Kerberos for authentication.
  • Integration with the wider environment.

Looking back, this wasn’t automation. But it was something close. It was a repeatable pattern. A way of taking what worked last time and applying it again. Not everything in these documents came from me.

Some of it came from colleagues. Some from vendor documentation. Some from trial and error. But once something worked, I kept it. Wrote it down and used it again. That’s just how these documents grew. Not as perfect designs. But as collections of things that had proven themselves. Today, this would probably be:

  • Ansible
  • cloud-init
  • container images

Back then, it was a text file and a terminal. The intent was the same. Build something predictable. Build something consistent. Build something that works the same way every time. Even if the method was a little more manual.

Tags: