DEV Community: Paul Anaekwe

Top 10 Realities to Consider Before Pursuing a Career in DevOps

Paul Anaekwe — Sat, 09 Aug 2025 16:07:34 +0000

Having spent the last three years of my life navigating this industry and learning the skills necessary to thrive in DevOps, I can attest that it's a challenging but rewarding career for those who are committed to continuous learning, problem solving, and collaboration. I've created these 10 realities to prepare you for the unique demands of the job and set you up for long term success.

1. It's a Culture Shift, Not Just a Toolset
Many people think DevOps is simply knowing Docker, Kubernetes, and Jenkins. The reality is that these are just tools. The core of DevOps is a cultural philosophy that promotes collaboration, communication, and shared responsibility between development and operations teams. You'll spend a significant amount of time building bridges and breaking down organizational silos, not just writing code or configuring servers.

2. You Are a Generalist with Deep Specializations
I remember asking my tutor if I was learning full-stack development because I hadn't signed up for coding, networking, or other such things. I was willing to learn Kubernetes and containers without any coding, but I was wrong.

A DevOps engineer is often a jack of all trades. You'll need to understand a wide range of topics, including:

Coding and scripting (Python, Bash, Go)

Linux fundamentals and system administration

Networking concepts (DNS, TCP/IP, firewalls)

Cloud platforms (AWS, Azure, GCP)

CI/CD pipelines

Containers and orchestration (Docker, Kubernetes)

While you don't need to be an expert in everything at once, you'll be expected to have a solid foundation in these areas and be able to dive deep into specific problems.

3. Continuous Learning is Not an Option, It's a Requirement
If you're not trying to learn new tools on a regular basis, then DevOps may not be for you.

The DevOps landscape evolves at a blistering pace. New tools and technologies emerge constantly. What's popular today (e.g., Kubernetes) might be replaced by something else in a few years. To stay relevant, you must be a proactive and perpetual learner. If you don't enjoy learning new things, this career path could be a source of constant frustration.

4. You're Responsible for the Unbreakable Infrastructure
DevOps engineers are often the last line of defense. When a production system goes down at 2 a.m., it's often a DevOps engineer who gets paged. While the goal is to build automated, self-healing systems, incidents still happen. The stress of being on call and troubleshooting critical issues is a very real part of the job.

5. Troubleshooting and Debugging Will Consume Your Time
This is probably my least appreciated task as a DevOps professional. Even though AI has made it easier to debug, you still need to ask the right questions and sometimes it can take an awful lot of time figuring out the problem.

While building and automating are exciting, a large portion of your day will be spent troubleshooting. You'll be debugging failed deployments, investigating performance issues, and sifting through logs to pinpoint the root cause of a problem. Strong problem solving skills are more valuable than memorizing every tool command.

6. Business First is the Golden Rule
Lest I forget, you can also be burdened with the responsibility of managing resources and making wise financial decisions, as that can be one of the skills by which you will be judged as a good or bad DevOps professional.

Your technical decisions, no matter how cool they seem, must always align with business goals. You may have to forgo implementing a new, shiny tool because the business needs something simple, cost effective, or reliable right now. The best DevOps engineers understand that their job is to support the business, not just to play with technology.

7. Documentation is as Important as Your Code
In a fast paced environment, it's easy to rush through a project and forget to document it. However, in DevOps, proper documentation is a lifesaver. Well documented pipelines, configurations, and processes save countless hours for your team and for your future self. You'll need to cultivate the discipline to document everything from day one.

8. Communication and Collaboration are Your Superpowers
The "Ops" in DevOps stands for operations, but the "Dev" is just as important. You will work closely with developers, security teams, and product managers. Your ability to communicate complex technical concepts to non technical people is essential for success. This is a role built on teamwork.

9. Not Every Company has a True DevOps Culture
Many companies say they're "doing DevOps," but in reality, they may just have a team of sysadmins with new titles. They might still have rigid silos, a lack of automation, or a blame first culture. As a DevOps aspirant, you need to be aware of this and ask the right questions during interviews to gauge a company's true cultural maturity.

10. The Pay and Career Growth are Insane
Despite the challenges, a DevOps career is incredibly rewarding. Due to the high demand for these skills, DevOps engineers are among the highest-paid professionals in the tech industry. The career path is also rich with opportunities, from becoming a Lead DevOps Engineer to specializing as a Site Reliability Engineer (SRE) or even transitioning into a management or architect role.

Conclusion
DevOps is a challenging yet fulfilling career that demands a broad skill set and a collaborative mindset. By understanding these realities, you can prepare yourself for the unique demands of the job and embark on a successful journey in this dynamic and rewarding field.

The DevOps Superpower That Is Shell Scripting

Paul Anaekwe — Fri, 25 Jul 2025 03:27:14 +0000

Ever wondered how DevOps engineers seem to whip up automated magic? How they deploy applications with a single command, or get their servers to sing in perfect harmony? Often, the secret sauce is something surprisingly simple yet incredibly powerful: Shell Scripting.

Today, we're diving into the wonderful world of shell scripting, specifically how it empowers DevOps practitioners to automate, orchestrate, and generally make their lives a whole lot easier. Think of it as teaching your computer to do your bidding, all while you kick back and enjoy a well deserved coffee.

What in the DevOps is Shell Scripting Anyway?

In my own words, shell scripting for DevOps is like giving your computer a personalized set of instructions, written in its native language, to perform a series of tasks automatically. Imagine you're a conductor for a choir, and your computer is the orchestra. Instead of shouting out "Play the violins! Now the trumpets! Now everyone at once!", you write down a musical score that dictates every move.

Why is this a big deal for DevOps? Well, DevOps is all about speed, efficiency, and reducing manual errors. And what's more efficient than having a machine do repetitive, error prone tasks for you?

Examples in the Wild:

Automating Deployments: Instead of manually logging into servers, copying files, and restarting services, a shell script can handle the entire deployment process from start to finish. It's like having a tiny, super-fast robot do your grunt work.

Setting up Development Environments: Need to get a new developer up and running? A script can install all necessary software, configure settings, and even download project dependencies. No more "did you remember to install Node.js?" questions!

Monitoring and Alerting: Scripts can regularly check the health of your applications and servers. If something goes wrong, they can send you an alert maybe even a polite little email saying, "Hey, your server is feeling a bit under the weather."

Backup and Recovery: Automate your data backups with scripts that run at scheduled intervals, ensuring your precious information is always safe. Because losing data is about as fun as stepping on a Lego.

The Mystery of #!/bin/bash and #!/bin/sh

You've probably seen these lines at the very beginning of shell scripts. They look a bit like secret codes, don't they?

#!/bin/bash: This is called a "shebang" (yes, that's really what it's called, not a typo!). It tells your operating system, "Hey, this script needs to be executed using the bash interpreter!" Bash is a powerful and popular shell program that understands a wide range of commands and scripting features. Think of it as the ultimate language for talking to your Linux/Unix system.

#!/bin/sh: This is another shebang, but it points to the sh interpreter. sh is often a symbolic link to a more basic shell, like dash or bash itself, but running in a more POSIX compliant (standardized) mode. This means it might not support all the fancy features that bash offers.

Can we write #!/bin/sh as well? Absolutely! You can use #!/bin/sh if you want your script to be more portable and compatible across different Unix like systems, as sh aims for a common set of features. However, if you're leveraging advanced Bash specific features (like associative arrays or more complex pattern matching), then #!/bin/bash is your go to. It's like choosing between a classic, reliable car (sh) and a souped up, feature rich sports car (bash). Both get you from A to B, but one has more bells and whistles!

Let's Write Our First Script!: Shell Script Challenge

Let's write a simple script that prints a message. Open your favorite text editor, type the following, and save it as devops_challenge.sh:

Now, to make it executable:

Bash

chmod +x devops_challenge.sh

And to run it:

Bash

./devops_challenge.sh

Output:

I will complete #90DaysOfDevOps challenge.

Boom! Your first shell script. Feeling powerful yet? You should be!

Lets Get A Bit Chatty: User Input and Arguments

Shell scripts can also interact with you and take information from their environment.

Let's create a script called interactive_script.sh:

Now, let's run it. First, just with user input:

chmod +x interactive_script.sh
./interactive_script.sh

It will prompt you for your name. Enter "DevOps Enthusiast" (or whatever you like!).

Example Output (user input part):

Hello there! What's your name?
DevOps Enthusiast
Nice to meet you, DevOps Enthusiast!
Now, let's see some arguments.
The first argument is:

The second argument is:

All arguments are:

The number of arguments is: 0
Script finished. Hope you learned something cool, DevOps Enthusiast!

Now, let's run it with some arguments:

./interactive_script.sh "Shell Scripting" "Rocks!"

Example Output (with arguments):

Hello there! What's your name?
DevOps Ninja
Nice to meet you, DevOps Ninja!
Now, let's see some arguments.
The first argument is: Shell Scripting
The second argument is: Rocks!
All arguments are: Shell Scripting Rocks!
The number of arguments is: 2
Script finished. Hope you learned something cool, DevOps Ninja!

See how easy it is to get information into your scripts? It's like they're having a conversation with you!

The Art of Decision-Making: If-Else Statements

Just like humans, scripts need to make decisions. "If this happens, do that. Else, do something else." This is where if else statements come in, and they're fundamental to any meaningful script.

Let's compare two numbers, with a subtle joke or two. Create a file called compare_numbers.sh:

Now, let's run it with different numbers:

Scenario 1: First number is greater

*chmod +x compare_numbers.sh
./compare_numbers.sh 10 5 *

Output:

10 is greater than 5. Looks like 10 spent more time at the gym!
Comparison complete! Thanks for playing.

Scenario 2: Second number is greater

*./compare_numbers.sh 7 15 *

Output:

15 is greater than 7. 7 is probably just playing it cool.
Comparison complete! Thanks for playing.

Scenario 3: Numbers are equal

*./compare_numbers.sh 8 8 *

Output:

8 and 8 are equal. They must be twins, or perhaps they're just perfectly balanced, as all things should be.
Comparison complete! Thanks for playing.

Scenario 4: Missing arguments

./compare_numbers.sh 10

Output:

Oops! I need two numbers to compare, my friend. Like, really, truly two numbers.
Usage: ./compare_numbers.sh

See how the if-else (and elif for "else if") allows your script to adapt and respond differently based on conditions? It's the brains of the operation!

Conclusion

Shell scripting is an invaluable skill for any aspiring or seasoned DevOps professional. It's the glue that holds automation together, allowing you to streamline workflows, reduce errors, and reclaim your precious time. From simple tasks to complex orchestrations, shell scripts are your loyal, tireless assistants.

So, go forth, embrace the shebang, and start scripting! Your future automated self will thank you for it. And who knows, maybe one day your scripts will be so smart, they'll write blog posts about you! (Just kidding... mostly.)

Level Up Your Linux Game: Mastering Essential File and Directory Commands

Paul Anaekwe — Wed, 23 Jul 2025 17:03:01 +0000

Welcome, fellow Linux enthusiasts! Whether you're a seasoned command-line veteran or just starting your journey, understanding fundamental file and directory manipulation is crucial. In this blog post, we'll tackle some common tasks you'll encounter daily, equipping you with the knowledge to navigate and manage your Linux environment like a pro. Let's dive in!

Peeking Inside: Viewing File Content with Line Numbers

Ever needed to examine the contents of a file while keeping track of each line? Linux provides elegant solutions for this. The cat command, short for concatenate, is a go-to tool for displaying file content. To add line numbers to your output, simply use the -n flag:

Command:

cat -n filename.txt

Setting Boundaries: Managing File Permissions
Linux's robust permission system allows you to control who can read, write, and execute your files. To grant the owner (user) full read, write, and execute permissions while denying any access to others (group and others), the chmod command is your friend. Using symbolic mode, you can achieve this with:

Command:

chmod u=rwx filename.txt

Here, u stands for the user (owner), and =rwx sets the read, write, and execute permissions. Numerically, this translates to 700, where each digit represents the permissions for the owner, group, and others, respectively (4 for read, 2 for write, 1 for execute). Thus, the equivalent numeric command is:

Command:

chmod 700 filename.txt

This ensures that only the owner of paulanaekwe.txt has full control over it.

Looking Back: Reviewing Your Command History

Mistakes happen, or sometimes you just need to recall a command you ran recently. The history command is your personal time machine for the command line. To view the last 10 commands you executed, simply type:

Command:

history | tail -n 10

This will display a numbered list of your most recent commands, making it easy to review or even re-execute them using !n (where n is the command number).

Going Nuclear: Removing Directories and Their Contents

When it's time to say goodbye to a directory and everything within it, the rm command with the -r (recursive) flag is essential. Be cautious with this command, as it permanently deletes files and directories.

Command:

rm -r directoryName

For a more forceful removal without prompts, you can add the -f (force) flag:

Command (Use with caution!):

rm -rf directoryName

This command will ruthlessly delete directoryName and all its subdirectories and files without asking for confirmation.

File Creation and Population: Working with fruits.txt

Let's create a file named fruits.txt and populate it with a list of our favorite fruits, one per line. We'll use the echo command along with output redirection (>) to achieve this:

Command:

echo -e "Apple\nMango\nBanana\nCherry\nKiwi\nOrange\nGuava" > fruits.txt

The -e option in echo enables interpretation of backslash escapes, allowing us to use \n to create newlines. To verify the content, we can use cat:

Adding More Goodness: Appending to fruits.txt

This means adding content to the end of a file, like adding pineapple to the fruit.txt file

To add "Pineapple" to the end of our fruits.txt file, we'll use the append redirection operator (>>):

Command:

echo "Pineapple" >> fruits.txt

The >> operator adds the output to the end of the file without overwriting the existing content that is why you can see from the picture above that we now have pineapple at the end of the list.

Top Three in Reverse: Ordering File Content

Sometimes you need to focus on specific parts of a file. To display the first three fruits from fruits.txt in reverse alphabetical order, we can combine the head and sort commands using a pipe (|):

Command:

wc fruits.txt Colors.txt

head -n 3 extracts the first three lines, and the pipe sends this output to sort -r, which sorts the lines in reverse order.

Bottom Three, Alphabetically: Another Look at Ordering

Similarly, to see the last three fruits and then sort them alphabetically, we can use the tail command:

Command:

tail -n 3 fruits.txt | sort

tail -n 3 retrieves the last three lines, and sort arranges them in alphabetical order.

Introducing Colors: Creating and Populating Colors.txt

Let's create another file named Colors.txt and fill it with a list of colors:

Command:

echo -e "Red\nPink\nWhite\nBlack\nBlue\nOrange\nPurple\nGrey" > Colors.txt

This creates a new file named colors.txt and adds several colors into it

Adding to the Beginning: Prepending to Colors.txt (A Robust Method)

In an attempt to add yellow at the top of the list as the first item this method creates a temporary file with "Yellow" at the top, then concatenates the original Colors.txt to it, and finally replaces the original file. This is very robust.

command:

echo "Yellow" > temp_colors.txt
cat Colors.txt >> temp_colors.txt
mv temp_colors.txt Colors.txt

Explanation:

echo "Yellow" > temp_colors.txt: Creates a new file temp_colors.txt and puts "Yellow" into it.

cat Colors.txt >> temp_colors.txt: Appends the entire content of your Colors.txt to temp_colors.txt. Now temp_colors.txt has "Yellow" at the top, followed by all your original colors.

mv temp_colors.txt Colors.txt: Renames the temp_colors.txt file to Colors.txt, effectively replacing your old file with the new, modified one.

Finding Common Ground: Identifying Shared Lines

To discover the lines that are present in both fruits.txt and Colors.txt, the comm command is invaluable. It compares two sorted files line by line. To display only the common lines, we use the -12 flags:

Command:

comm -12 fruits.txt Colors.txt

(Note: comm requires the input files to be sorted for accurate results. If your files are not sorted, you might want to sort them first using sort fruits.txt > sorted_fruits.txt and then use comm -12 sorted_fruits.txt sorted_colors.txt.)

Counting It All: Lines, Words, and Characters

Finally, to get a statistical overview of our files, the wc command (word count) is perfect. It provides the number of lines, words, and characters in the specified files:

Command:

wc fruits.txt Colors.txt

This will display a table with the line count, word count, character count, and filename for both fruits.txt and Colors.txt, along with a total.

Conclusion: Your Linux Command Arsenal Grows!

Congratulations! You've now learned how to perform several essential file and directory operations in Linux. Mastering these basic commands will significantly enhance your command-line proficiency and empower you to navigate and manage your Linux system with greater ease and confidence. Keep practicing, and you'll be a Linux power user in no time! Stay tuned for more Linux tips and tricks in future blog posts.

Demystifying DevOps

Paul Anaekwe — Mon, 21 Jul 2025 21:34:15 +0000

Your DevOps Roadmap: Where to Start?

Feeling excited about the possibilities of making your business tech run smoother? Implementing DevOps isn't an overnight sprint; it's a journey. Think of it like building a new wing for a booming shop you don't just put up walls randomly. Here's a simplified roadmap to guide your organization:

Start with the Culture Shift (Team Talk First)
Begin by fostering better communication and collaboration between your development and operations teams. Encourage them to understand each other's challenges and goals.

Automate What Hurts Most (Fix the Biggest Wahala)
Identify the most painful, time-consuming, and error-prone manual tasks in your software delivery process. Could it be testing, setting up new environments, or deploying code?

Implement Continuous Integration (Frequent Updates, No Surprises)
Get developers to merge their code changes frequently into a central place, where automated tests run immediately. This catches problems early.

Embrace Infrastructure as Code (Blueprint Your Systems)
Start treating your IT infrastructure (servers, networks, databases) like software code. Write scripts to automatically provision and manage them.

Monitor Everything (Eyes on the Market):
Implement robust monitoring tools to keep a constant eye on your applications and infrastructure in production. This helps you detect issues quickly and understand performance.

DevOps is an ongoing journey. Regularly review your processes, learn from failures and successes, and make small, continuous improvements.

Demystifying DevOps and Tech for Every Nigerian Business

A few years ago, my family friend whom we referred to as Uncle Emeka ran a booming provision store in Surulere. Business was great, but managing stock, tracking sales, and ordering new goods was a constant headache. He relied on notebooks, phone calls, and sheer willpower. When a new shipment of popular drinks arrived, he’d often realize too late that he’d already run out of space, or worse, forgotten to order enough of a fast-moving item like Indomie noodles.

His biggest challenge wasn't attracting customers; it was the behind-the-scenes chaos. Every new order, every customer wanting a specific item, felt like a mini crisis. He was always reacting, never truly in control. It reminded me a lot of how many businesses still handle their technology – reactive, manual, and often overwhelmed by growth.

This is where understanding some key tech concepts can turn that chaos into a smooth operation...

What is DevOps?

Imagine you're running a very busy buka or local eatery in Surulere Lagos. In the past, the person who buys all the ingredients and plans the menu would just cook up the food and then tell another person to just serve it to customers and manage the daily sales. Sometimes, the chef might cook something the server doesn't know how to handle, or the server might need something urgently that the chef didn't prepare. This can lead to delays, wasted food, and unhappy customers waiting for their amala.

DevOps is like getting the chef and the server/manager to work hand-in-hand, like fufu and egusi, from the moment they plan the day's menu to when the last customer leaves. They share ideas, share responsibility for making sure the food is ready and served right, and even help each other out.

So, if my descriptions of DevOps felt more like a recipe for collaboration than a tech strategy, please forgive me. It's just that I believe understanding complex concepts is a bit like appreciating good food it's all about the flavor, process, and how well it satisfies your hunger for knowledge.

I hope, despite the culinary detours, the core ideas were digestible!

Think of it as

Better Teamwork: The chef and server communicate constantly, like a close family working together, making sure everyone knows what's needed.

Faster Service: Because they're in sync, customers get their jollof rice and fried plantain much quicker, hot and fresh.

Smoother Operations: If a popular dish runs out, they can quickly figure out how to restock or offer alternatives without causing a commotion.

What is Automation, Scaling, and Infrastructure?

Automation

Automation in IT refers to the use of software and tools to perform repetitive IT tasks and processes with minimal human intervention. It involves creating automated workflows that can execute tasks more quickly, consistently, and accurately than manual methods.

In our tech world, automation means we use smart software to do things like:

Testing new features: Instead of someone manually checking if our mobile app's transfer money function works every single time, a program does it automatically, like a super-fast, error-free auditor, catching issues before anyone notices.

Getting updates out: When we have a new version of our app, automation helps us release it to everyone with just a click, like a well-organized distributor quickly stocking every shop, instead of someone driving around Lagos delivering updates manually.

Setting up new systems: If we need a new server for our app, automation can build and configure it instantly.
Why is this good? It means fewer errors (no more counting mistakes!), things get done much faster, and our tech team can focus on creating new, exciting things for you, like a new fintech product, instead of just repeating dull tasks.

Scaling

Think about your market stall. What happens if suddenly everyone in Lagos wants to buy your Aso-Oke? If your stall can only serve 10 customers at a time, you'll have a queue stretching down the street, and customers will leave! Scaling is about making sure our technology can handle more and more customers or transactions without our "stall" collapsing.

There are two main ways we scale:

Vertical Scaling (Bigger Stall): This is like making your single stall bigger by adding more shelves and more display space. It works for a while, but eventually, your stall can only get so big.

Horizontal Scaling (More Stalls): This is like opening more, smaller stalls in different parts of the market, or even new markets entirely. So, you can serve many more customers by spreading the work. If one stall has a problem, the others keep selling. In tech, this means we can add more computers (servers) to handle more users or data.

Why is this good?

It means our systems can grow as our business grows, so we can handle more customers downloading our app, more people making payments, and more activity without our service slowing down or crashing, just like a danfodriver handling a rush hour crowd.

Infrastructure

If our company was a bustling market, the infrastructure would be everything that makes the market function: the land it's built on, the security guards, the electricity supply (even if it's via a generator sometimes!), the water tankers, the waste disposal, and all the actual stalls and warehouses.

In the tech world, our infrastructure includes:
Computers (Servers): These are like the big, powerful generators and storage rooms in our market. They store our app's data and run all its operations.

Networks: These are the "roads" and "communication lines" that connect all our computers, allowing them to talk to each other and to the internet, like the market's internal walkie-talkie system and the roads customers use to get there.

Databases: These are like the super-organized ledgers or storage rooms where we keep all our important information, like customer accounts, transaction records, or product inventory.

Cloud Services: Increasingly, we "rent" our infrastructure from big global tech companies (like AWS or Google Cloud), who manage the physical computers and networks for us in their massive, secure data centers around the world. This is like renting space in a huge, modern shopping mall with reliable power and security, instead of building our own market from scratch.
Why is this good? It's the bedrock for everything we do. Without solid infrastructure, our apps wouldn't run, our customers' data wouldn't be safe, and our operations would grind to a halt, like a market without power or security.

Why is DevOps Important?

DevOps isn't just another oyinbo tech term; it's genuinely important for the success of our business here in Nigeria because it helps us:

Deliver Faster (Sharp Sharp!): We can get new features and improvements into your hands, our customers, much more quickly. This means we can respond faster to what people need and offer solutions before our competitors do. Imagine getting a new banking feature that makes life easier, almost as soon as you think of it!

Higher Quality and Reliability (No Wahala!): By testing constantly and working closely, we catch problems earlier. This means our products are more stable, have fewer issues, and work reliably every time you use them, like a generator that never fails in a blackout.

Increased Efficiency (Saving Time and Money): Automating tasks means our tech team isn't wasting time on boring, repetitive work. They can focus on brilliant ideas and building the next big thing, like a savvy trader using a POS machine instead of counting cash all day.

Better Teamwork: DevOps breaks down the silos, making our tech teams work like a tight-knit family or community (egbe), where everyone is pulling in the same direction. This leads to better understanding and smoother operations.

More Innovation: Because we're not bogged down by slow, manual processes, our teams have more time to think about groundbreaking solutions, like developing new ways for people in rural areas to access digital services.

Better Customer Satisfaction (Our Customers Are King/Queen!): Delivering high-quality, new features frequently, with fewer issues, directly means our customers are happier and keep coming back for more.

Stronger Business: All of this adds up to a more agile, responsive, and competitive business. We can adapt faster, serve our customers better, and stay ahead in Nigeria's fast-paced digital landscape.
In short, DevOps helps us run our technology operations like a well-organized festival – everything flows smoothly, everyone is happy, and the party keeps going without a hitch!