From Hello World to High Availability: My Dive into DevOps

Stepping into the world of DevOps as a fresh-faced intern is a bit like being handed a treasure map, only to find it’s written in a mix of ancient runes and hieroglyphs. The sheer number of tools, languages, and platforms can be overwhelming. But armed with a solid foundation from school, I’ve managed to navigate this maze, one cryptic clue at a time. In this article, I’ll walk you through the array of tools and technologies I’ve encountered—from the familiar comforts of the classroom to the sprawling ecosystems of the professional world.

Programming Languages: Java, Python, HTML, CSS, and JavaScript

Our foray into the world of programming began with the classics: Java and Python. Java, with its robust structure and object-oriented design, gave us the discipline we needed to build scalable applications. Python, meanwhile, was the charming rogue—quick, efficient, and incredibly user-friendly, perfect for those scripts and automation tasks we needed to whip up in a jiffy. Alongside these stalwarts, we poked about into the trinity of web development: HTML to structure our content, CSS to make it look halfway presentable, and JavaScript to sprinkle a bit of magic and interactivity onto our pages.

Databases: PostgreSQL, MySQL, MariaDB, and MongoDB

Databases are the unsung heroes of most applications, quietly keeping everything in order. At school, we cut our teeth on relational databases like PostgreSQL, MySQL, and MariaDB. These tools hammered home the importance of data integrity, SQL queries, and understanding the relational model. We also dabbled in creating ER-diagrams (Entity-Relationship Diagrams)—those fancy flowcharts that map out how different data entities relate to one another. But as I ventured further into DevOps, I encountered MongoDB, a NoSQL database that threw the traditional relational rulebook out the window. Its flexibility was a revelation, especially when dealing with unstructured data that didn’t quite fit into neat, orderly tables.

Version Control: Git, GitHub, and Git Bash

Version control is the cornerstone of collaborative development. In school, we were introduced to Git and GitHub—our trusty sidekicks in managing code repositories, creating branches, and avoiding the dreaded merge conflicts. Git Bash was the command-line interface that allowed us to wrangle Git with all the finesse of a seasoned coder (or so we liked to think). These tools were indispensable for keeping our projects on track and ensuring that everyone’s work played nicely together.

Integrated Development Environments: IntelliJ and Visual Studio Code

When it came to writing code, we had two trusty companions: IntelliJ and Visual Studio Code. IntelliJ was the heavyweight champion for developing Java applications, offering powerful refactoring tools and debugging capabilities that made us feel like coding ninjas. Visual Studio Code, on the other hand, was the Swiss Army knife of IDEs—lightweight, extensible, and perfect for everything from Python scripts to HTML, CSS, and JavaScript web development. It was our go-to tool for just about anything, and we quickly became adept at customising it to suit our every whim.

Infrastructure and Server Management: Nginx, Ubuntu, Apache, and Node.js

Understanding how servers work is a crucial part of DevOps. In school, we set up simple servers using Nginx on Ubuntu—our trusty Linux distribution of choice. We also played around with Apache and Node.js, learning how to configure these servers, manage security settings, and optimise performance. These early experiences taught us the importance of a solid infrastructure, especially when dealing with large-scale applications that demanded reliability and speed.

Security and Certificates: SSH, TLS, HTTPS/HTTP, Let’s Encrypt, and Certbot

Security isn’t something you can afford to take lightly, especially in DevOps. We learned about SSH (Secure Shell) for secure remote access to servers and the importance of TLS (Transport Layer Security) for encrypting data as it travels across the internet. Setting up HTTPS for our web applications became second nature, often using Let’s Encrypt and Certbot to obtain and renew SSL certificates. These tools made the process almost too easy—like being handed the keys to the kingdom with a friendly reminder not to lose them.

Process Management and Scaling: PM2, Reverse Proxy, and Scaling Servers

Managing application processes and scaling infrastructure were skills we honed early on. We used PM2 to manage Node.js applications, ensuring they ran smoothly even after a server reboot. Understanding reverse proxy setups with Nginx allowed us to balance load across multiple servers, making sure our applications could handle whatever the internet threw at them. Scaling servers up or down, whether they were Windows or Linux based, was an important lesson in resource management, especially when the stakes were high, and downtime wasn’t an option.

Containerisation and Orchestration: Docker, Docker Hub, Docker Desktop, Kubernetes, Minikube

The shift from traditional server setups to containerised environments was nothing short of revolutionary. Docker became our go-to tool for creating consistent development environments, packaging applications with all their dependencies. Docker Hub was where we shared these containers, and Docker Desktop made it easy to manage them locally. When it came to orchestration, Kubernetes and Minikube took things to the next level, introducing us to the world of managing clusters of containers, and ensuring scalability and resilience in production environments.

Microservices and Continuous Integration/Delivery: Jenkins, Istio, Prometheus, Grafana

Modern application development often revolves around microservices, where each service is independently deployable. Jenkins was our introduction to setting up continuous integration (CI) pipelines, and automating the testing and deployment of microservices. Istio added a service mesh layer, giving us control over the communication between services. Monitoring these systems was made easier with Prometheus for metrics collection and Grafana for visualisation, ensuring that our microservices architecture was performing optimally, like a well-tuned orchestra.

Content Management and Web Development: WordPress and PHP

On the web development front, we played around with WordPress—a popular content management system (CMS) built on PHP. Setting up and maintaining WordPress sites gave us hands-on experience with deploying web applications, managing databases, and handling user traffic. We also got to grips with customising themes and plugins, diving deeper into the world of PHP and its role in dynamic web development. It was like building with Lego, only the blocks were lines of code, and the end result was a fully functional website.

Scripting and Automation: Bash Scripting, CI/CD, and Manual Testing and testplanning

Scripting and automation are the beating heart of DevOps. We learned bash scripting for automating repetitive tasks on Linux systems—everything from backups to updates to deployments. Setting up Continuous Integration/Continuous Delivery (CI/CD) pipelines was the next logical step, automating the entire process from code commit to deployment. Despite all this automation, manual testing and test planning remained essential. Test planning helped us organise our testing efforts, ensuring we covered all the bases and weren’t just poking around in the dark. With a solid test plan, we knew exactly what to test, how to test it, and what the expected outcomes were, making manual testing a more structured and reliable process. After all, there’s nothing quite like a good old-fashioned checklist to catch those sneaky bugs.

Agile Methodology: Sprint Planning Retrospectives and Agile Practices

Finally, understanding the process behind the technology was just as important. We were introduced to Agile methodology, where sprint planning, daily stand-ups, and iterative development cycles became our new normal. Sprint planning was our time to set goals, decide what work would be done, and allocate resources effectively. But it didn’t stop there—retrospectives at the end of each sprint were just as crucial. They gave us the chance to reflect on what went well, what didn’t, and how we could improve in the next sprint. This continuous loop of planning, doing, and reflecting not only helped us deliver projects more efficiently but also taught us the importance of collaboration and adaptability in fast-paced environments. It was a bit like running a marathon, except the course kept changing, and sometimes you had to sprint.

Conclusion: Bridging the Gap from School to Professional DevOps

Transitioning from the tools we used in school to the vast, intricate ecosystem of professional DevOps has been both a challenging and rewarding journey. Each tool and technology we've encountered has served as a building block, helping us piece together the larger puzzle of how modern software is developed, deployed, and maintained.

But if I’m being completely honest, there are days when I feel like I’m navigating a labyrinth with only half a map, and the minotaur is just around the corner. I’m still very much at the beginning of this journey, and let’s just say I’ve got a long way to go before I can confidently say I’ve “mastered” anything. The complexity of it all is still a bit intimidating, and there are moments when I’m convinced that everyone else has received a secret handbook that I’ve somehow missed. In short, I’m still a newbie, fumbling through the dark and hoping I don’t trip over my own feet.

For anyone embarking on a similar path, my advice is simple: embrace the learning curve with the enthusiasm of a Labrador chasing its tail. The tools may seem complex, the jargon may feel endless, and there will undoubtedly be moments when you question your life choices. But with patience, practice, and a sense of humour firmly intact, the pieces will start to fit together. Whether you’re setting up a simple server or orchestrating a fleet of containers, every experience adds to your understanding of the DevOps landscape—and gives you a few more stories to tell.

So, what about you? Are you just starting out in DevOps, or are you already knee-deep in YAML files and Docker containers? What tools have you found indispensable, and what challenges have you faced along the way? Let’s have a chinwag—I’d love to hear your story, share in the journey, and maybe even swap tales of those “what on earth am I doing?” moments. After all, if we’re going to stumble through this maze, we might as well do it together!