DEV Community: Shreyas Vithalkar

🚀 Day 3 of My 90-Day DevOps Journey: Vim Editor and Linux File Types

Shreyas Vithalkar — Tue, 03 Dec 2024 15:55:00 +0000

Welcome back to Day 3 of my DevOps journey! Today, I explored the Vim editor and learned about the types of files in Linux. Let’s dive in!

🖋️ Vim Editor Basics

Vim is a highly efficient text editor that’s perfect for editing files in Linux. It operates in two primary modes:

Command Mode: For executing commands.
Insert Mode: For writing and editing text.

🛠️ Essential Vim Commands

Switching Modes:
- Press i → Enter Insert mode.
- Press Esc → Return to Command mode.
File Operations:
```
:w     # Save the file  
:q     # Quit Vim  
:wq    # Save and quit  
:q!    # Quit without saving
```
- Text Navigation:
  - h → Move left
  - l → Move right
  - j → Move down
  - k → Move up
- Editing:
  - x → Delete a character
  - dd → Delete a line
  - yy → Copy a line
  - p → Paste copied content
- Search and Replace:
```
/pattern      # Search for 'pattern'  
:%s/old/new/g # Replace 'old' with 'new' globally 
```

📂 Types of Files in Linux

Linux files come in various types, each serving a unique purpose. Here’s what I learned:

Regular File:
- Stores data like text, scripts, or binaries.
- Command to check:

ls -l file.txt

Look for a `-` at the start of the permissions (`-rw-r--r--`).

Directory:
- Contains other files or directories.
- Identified with a d in permissions (drwxr-xr-x).
Link File:
- A shortcut to another file. (This you can consider as a Desktop short for any file/application in Windows) Can be:
  - Hard Link: Points directly to the file's data.
```
ln file.txt hardlink.txt
```
  - Soft Link: Points to the file's location.
```
ln -s file.txt softlink.txt
```
- Use unlink filename to unlink a file.
Special File:
- Represents devices like printers or disks, typically found in /dev.
Socket:
- Enables communication between processes, often used in networking.
Block File:
- Represents devices that transfer data in blocks (e.g., hard drives).

🔍 Command to Identify File Types:

Use the file command to determine a file’s type:

file filename

Also a bonus thing, some options on our ls command

ls -l

The above command with -l option is long listing of files (Sorts Alphabetically)

ls -lt

Sort by Timestamp, (Latest first/ Last modified)

ls -ltr

The -r option is for reverse sorting. And in the above example, it will sort old modified files first.

✨ Key Takeaway

Today, I took a big step in strengthening my Linux foundation. Mastering the Vim editor and understanding file types are crucial skills for any DevOps engineer. 🚀

Stay tuned for more as I continue my journey to DevOps mastery!

🚀 Day 2 of My 90-Day DevOps Challenge: Exploring Linux Basics

Shreyas Vithalkar — Mon, 02 Dec 2024 19:11:41 +0000

Today, I started my journey into Linux, an essential skill for any DevOps engineer. From exploring the Linux file system to mastering basic commands and the Vim editor, here’s what I learned. 🐧

📂 Key Linux Directories

/usr/home: Holds user-specific files, configurations, and personal data.
/bin: Contains essential system commands like ls, cp, and mv.
/etc: Stores configuration files for the system and applications.
/tmp: Temporary files created by processes or applications, usually cleared on reboot.
/var: Contains variable data like logs, caches, and queues. Logs are often helpful for debugging.
/lib: Shared libraries and modules used by executables in /bin and /sbin.

🛠️ Basic Linux Commands

File and Directory Operations

Create a file: Used to create an empty file or update the timestamp of an existing file.

touch file.txt

Creates an empty file named file.txt.

Copy a file: The cp command is used to copy files and directories.

cp source.txt destination.txt

Copies source.txt to destination.txt.

cp -r source_directory/ destination_directory/

Copies the entire contents of source_directory into destination_directory. The -r option ensures all files and subdirectories are copied.

Move or rename a file: The mv command is used to move or rename files.

mv file.txt /path/to/destination/

Moves file.txt to the specified destination directory.

mv oldname.txt newname.txt

Renames oldname.txt to newname.txt.

Display file contents: The cat command is used to display the contents of a file.

cat file.txt

Displays the contents of file.txt.

List files in a directory: The ls command lists the contents of a directory.

ls

Lists all files and directories in the current directory.

ls -l

Displays detailed information like permissions, ownership, and file size.

ls -a

Lists all files, including hidden ones (those starting with .).

Make/Create Directories: Used to create directories.

mkdir new_directory

Creates a single directory.

mkdir -p parent_directory/child_directory

The -p option creates parent directories if they don’t exist.

Remove Files or Directories: The rm command is used to delete files or directories.

rm file.txt

Removes a file.

rm -r directory_name

The -r option ensures recursive deletion of all contents in the directory.

By understanding these commands with their options (-r, -a, etc.), you can efficiently manage files and directories in Linux systems.

✨ Key Takeaway

Today’s learning covered the foundational Linux commands to create, copy, move, and view files, as well as navigate directories. Mastering these commands is a critical first step toward becoming proficient in Linux, a core skill for any DevOps professional! 🚀

Stay tuned for more amazing content 😀.

🚀 Day 1 of My 90-Day DevOps Journey: Understanding DevOps

Shreyas Vithalkar — Sun, 01 Dec 2024 16:23:14 +0000

Introduction

Hi! I’m Shreyas 👋, a developer on a 90-day mission to master DevOps. I’ll be learning and sharing my progress daily with bite-sized insights. If you're curious about DevOps or just starting your journey, let’s explore it together! 💡

So this is the Day 1 of my journey. Lets gets started:

What is DevOps?

DevOps is a culture, methodology, and set of practices that unify software development (Dev) and IT operations (Ops). It emphasizes:

Collaboration: Developers and operations teams work together.
Automation: Replacing manual tasks with tools and scripts.
Continuous Integration/Continuous Deployment (CI/CD): Ensuring rapid, reliable software delivery.

Key Benefits of DevOps

Speed: Faster release cycles and quicker feedback.
Quality: Automated testing reduces bugs.
Scalability: Efficient processes make scaling applications seamless.

The DevOps Lifecycle

Image from: www.freepik.com

Plan: Define the project goals, requirements, and workflows.
Develop: Write and collaborate on code using tools like Git.
Build: Package the code into deployable artifacts.
Test: Validate functionality to catch bugs early.
Release: Manage versions and prepare for deployment.
Deploy: Push code to production or staging environments.
Operate: Maintain infrastructure and application stability.
Monitor: Observe performance and gather feedback for improvements.

What is CI/CD?

Continuous Integration (CI)

A devOps software development practice where the developer regularly merge their code changes into a central repository, after which automated builds and tests are run.

How it works:

Developers push code changes to a version control system (like Git).
A CI server (e.g., Jenkins, GitHub Actions) automatically builds and tests the code.
If the build or tests fail, the developer is notified.

Benefits of CI:

Prevents integration issues (the "it works on my machine" problem).
Ensures a stable codebase.
Saves time by identifying bugs early.

Continuous Deployment/Delivery (CD)

Continuous Delivery: Ensures code changes are always in a deployable state. Deployment is manual but can be triggered with a single click.
Continuous Deployment: Takes Continuous Delivery one step further by automating the deployment process. Code changes that pass tests are automatically deployed to production.

How CD works:

After successful CI, the application is built and packaged. Automated tools deploy the application to staging and production environments.
Monitoring tools ensure the new version works as expected.

Benefits of CD:

Reduces manual effort and risk of human error.
Speeds up the feedback loop between users and developers.
Allows teams to focus on building features rather than deployment.

Key Takeaway

Day 1 was all about setting the foundation for my DevOps journey. Understanding the principles of DevOps, the lifecycle, and the concepts of CI/CD has been an exciting start! 🚀

I’m thrilled to continue this learning adventure, diving deeper into tools, technologies, and best practices in the coming days. Stay tuned, and let’s master DevOps together one step at a time! 💡

💬 Got any tips or favorite tools? Let me know in the comments!