🚀 My DevOps Journey – Week 2: From Databases to Linux Depths

Day 1: Databases and Securing Communications

This week began with something that was familiar yet different, databases. My past experience with Firebase in Flutter gave me some comfort, but this was the first time I was working directly with MySQL and MongoDB in a Linux console environment.

I started with MySQL: installed it, grabbed the temporary root password from /var/log/mysqld.log, logged in via mysql -u root -p, and changed the password using:

SET PASSWORD = 'NewPass123!';

From there, I created databases, tables, users, and assigned permissions. Jumping into MongoDB, I learned about the configuration file in /etc/mongod.conf, explored logs file in /var/log/mongodb/mongod.log, and started the Mongo shell. Learned about creating collections with db.createCollection() and inserting data using JSON and it felt quite easy thanks to my past Firebase familiarity.

What stood out was working directly with databases from the terminal. That was something I have not done before. I’ve always used higher-level Framework packages like Firebase package in Flutter. This hands-on gave me a new perspective on how real-world applications talk to databases under the hood.

Then I also went on to TLS/SSL security and encryption.

Initially, I only understood SSL as “that thing which gives a lock icon on websites.” But learning about asymmetric encryption, public/private key pairs, and how CAs (Certificate Authorities) validate certificates was fascinating. It was really exciting for me to learn the whole flow here. I even went deep into openssl, CSR creation, and how browsers check certificates using their trusted CA store. The real-world example of a phishing using fake certificates made it much more interesting. I finally understood how TLS/SSL works not just in theory, but in practical end-to-end encryption and trust. Security isn’t just a topic, it’s a battlefield where technology defends users from deception.

Day 2: JSON, YAML & 2-Tier App Deployment

On Day 2, I moved into JSON and YAML. Creating nested dictionaries, lists of dictionaries, and running JSONPath queries became natural after some practice. My previous Flutter experience with configuration files really helped. I had also did the basic SQL knowledge from college. So, when crafting JSONPath queries, it helped me a lot.

Did some many Exercises on JPath Queries. Even though some of them got me thinking with nested dictionary in list and vise-versa, after doing multiple queries, it became easy for me.

But the real excitement came when I decided to take a simple e-commerce app that was available in a public GitHub repository and deploy it using a 2-tier architecture: one server for the database (MariaDB) and one for the web (Apache + PHP). It felt great doing something more project-oriented:

CREATE DATABASE ecomdb;
CREATE USER 'ecomuser'@'%' IDENTIFIED BY 'ecompassword';
GRANT ALL PRIVILEGES ON *.* TO 'ecomuser'@'%';

I configured Apache, PHP, and modified the index.php to point the frontend to the backend. Switching IPs and starting services. It felt like it was very basic one but even then, I had a good feeling about deploying a small application at by basic level training time.

Day 3: DevOps Foundations — Theory That Binds It All

I spent the day going through a complete Fundamentals of DevOps. Unlike tool-based learning, this was deeply theoretical. It walked me through the history, culture, and role-based storytelling of DevOps. Scenarios of a Businessperson, a QA person, a Data Scientist person. All gave me real-world context on how broken processes, silos, and poor communication plague software teams.

It wasn’t just about CI/CD — it was about collaboration, feedback loops, and flow. I saw how organizations struggle to align dev, ops, security, and product, and how DevOps emerged as a bridge between chaos and collaboration.

Although there were no commands to run, I found the learning enriching. But honestly, it did feel dry at times. I had to push through mentally and stay focused. What kept me going was knowing how much these philosophies shape real DevOps teams. This whole theory thing was not fun for me. But I knew that I should learn these theories as well because these would help me understand why DevOps is needed and all.

Day 4: LFCS Begins — Rediscovering Linux

Even though I had an academic exam coming the next day, my passion got the better of me — I dove into the Linux Foundation Certified SysAdmin (LFCS) course from KodeKloud.

The initial modules were already known ones but deeper. I learned the 4 ways to log into a Linux system (local text/GUI, remote text/GUI) and had a mini-research rabbit hole when I discovered that terminals used to be separate physical devices. That blew my mind, and I had a small google search and ChatGPT to know more about that and realized that infact it was true, and a console was used by an administrator person to boot a single system, and terminals were used by users in that single system. This really fascinated me

I explored SSH Daemon vs Client, realized how servers are accessed using keys, learned that OpenSSH is pre-installed in most Linux distros but not older Windows and has to install SSH Clients like PuTTY, and got excited learning the deeper reasons behind man, apropos, journalctl, and TAB autocompletion. One of the coolest tricks was cd - to return to the previous directory. I hadn’t known this simple option even if I had browed through Linux many times in the previous 2 weeks.

But the highlight of the day? Hard Links vs Soft Links.

ln file.txt hardlink.txt
ln -s file.txt softlink.txt

It fascinated me how hard links share inode numbers while soft links don’t. I even had a small doubt "If links exists, then why do we need cp? Links would help in reducing disk usage, right?" But after external research, I saw their real-world use cases. That sense of curiosity gave me momentum.

Day 5: Permissions and the Find Command — More Than Just ls

This was a full day of deep exploration. I worked on file ownerships, groups, and permissions.

I found out that even if you're the file's owner, you still need sudo to change its ownership. Using chown, chmod, stat, and understanding octal notations like 0644 made all the things of permissions clearer to me.

Special permissions like SUID, SGID, and Sticky Bit were initially hard to grasp but became easy after some exercises:

chmod 4755 myscript.sh  # SUID or chmod u+s myscript.sh
chmod 2755 myfolder     # SGID or chmod g+s myscript.sh
chmod 1755 shared_folder  # Sticky bit or chmod o+t myscript.sh

Then came the powerful find command. I used:

find / -size +512k
find . -perm 644
find . -cmin -5

And even find -perm /664 to get files matching any of those permission bits. I had fun escaping characters with \! in bash and truly grasped how search works in Linux. The -mtime vs -cmin distinction — especially what is considered "metadata" added a new layer to my understanding.

It’s these fine-grained control tools that make Linux a real sysadmin’s playground.

Day 6: Writing and Reflecting

Today was less about learning and more about documenting. I’m writing this blog, updating my GitHub repo, and preparing my LinkedIn post.

It’s wild how just a week ago I was writing about yum and Apache, and now I’m diving into encryption, SSH internals, and system permissions. The best part? I’m not just copying commands anymore. I understand them. And that’s a great feeling.

---

I want to thank Savinder Puri where one of his YouTube video helped me evolve from writing "gyan-style" blogs to sharing my real struggles, insights, and wins. Week 1 felt like a tech wiki. Week 2? This is my story.

Let’s keep pushing. See you in Week 3.