DEV Community: Prashant Pal

HTTP Basics🌍

Prashant Pal — Mon, 03 Mar 2025 10:11:57 +0000

Hi! Welcome back to the blogs again. It's been a while since I last uploaded my blogs. So in today's blog, I will try to explain what HTTP is and its basics. I am no expert; I'm just a learner who is trying to understand different things that are essential to my DevOps journey. Now let's begin.🚀

What is HTTP🌐

HTTP is a protocol that allows client to communicate with servers. Here client is web-browsers or apps. It follows Request Response Model. Clients send the request and server processes the request.

Request Structure📝

The request structure consist of:-

Request Line
Headers
Body(Optional)

Request Line
It defines the HTTP method, URL and HTTP version.

GET /users HTTP /1.1

Headers
It contains additional information like content type, authorizations etc.

Content-Type: application/json
Authorization: Bearer<token>

Body
It contains data for POST and PUT requests.

{  
    "name": "Pal",
    "email": "example mail"

}

Response Structure 🛠️

The response structure contains:-

Status Line
Headers
Body

Status Line
If the request was successful.

HTTP /1.1 200 OK

Headers
It contains metadata like content type and server details.

Body
The actual response data is stored in it.

{
    "id": 1,
    "name": "Pal",
    "email": "example mail"

}

Common HTTP Methods📜

There are five HTTP methods:-

GET - Retrieve data from server.
POST - Create a new resource.
PUT - Update an existing resources completely.
PATCH - Partially update a resource.
DELETE - Remove a resource.

HTTP Status Codes💬

Following are the code:-

200 OK - Request was successful.
201 CREATED - Resource successfully created.
400 BAD REQUEST - Client Sent invalid data.
401 UNAUTHORIZED - Authorization required.
403 FORBIDDEN - Client doesn't have permission.
404 NOT FOUND - Resource doesn't exist.
500 INTERNAL SERVER ERROR - Server side issue.

Hands On with POSTMAN API📱

I use Postman API to understand how these request works. Here are some screenshot for better understandings how things work.

Conclusion🎯

HTTP is a foundational protocol for the web, enabling communication between clients and servers. Understanding how HTTP requests and responses work, along with the status codes and HTTP methods, is crucial for anyone in DevOps or web development. Whether you're sending data, retrieving information, or debugging issues, HTTP knowledge will come in handy in every aspect of web applications. 🌍

Feel free to experiment with Postman or any other tools to get hands-on experience. By practicing, you’ll better grasp how HTTP plays an essential role in modern applications. Keep learning and building! 💻

Learning Git 101

Prashant Pal — Wed, 18 Dec 2024 09:25:28 +0000

📚 In my recent blogs, I've shared my Linux learnings so far. 🌐 Although I haven't yet written about Linux networking, I’ll soon compile what I’ve learned in that area. Today’s topic, however, is version control! 🔄 I’ll be focusing on GitLab, which is similar to GitHub, and I’ll share everything I’ve learned about using it. 🚀

Why There Is a Need for Git? 🤔

While working on a project different developers work on the same code 🧑‍💻👩‍💻. They have different roles in that project, like frontend, backend, testing, etc. 🖥️🔍 And we need to share the same code with different developers. So, how do we share the code with each other? 🤷‍♂️

Here comes Git! 🚀 In Git code is hosted centrally on the internet in a code repository 📂🌐. Now every developer has an entire copy of the code locally 💾. Code is fetched from the remote repository 📥 and pushed to the code repository 📤. Git knows how to merge changes automatically 🤖.

But there’s a problem when the same line is changed by two developers 🛑, Git can’t fix it, and it causes merge conflicts ⚠️. The best practice is to keep pushing and pulling to the repository 🔄. Version control keeps a history of changes 📜, and you can revert the commits you made ⏪.

Basic Concepts of Git 🛠️

Git is the most popular version control tool 🌟. Here are some key concepts you should know:

Remote Git Repository 🌐: These are centrally hosted repositories. You can manage them using various version control tools like GitHub, GitLab, Bitbucket, etc. 🖥️ It can be public or private 🔐.
Local Git Repository 💻: These repositories are hosted on your system.
History of Code 📜: You can view your Git history by typing the command git log.
Staging 📝: This is the area where you decide which changes to commit. Staging prepares the code for committing ✅.
Git Clients 🔧: These tools help developers interact with Git repositories.

Note 📝: Companies often use their own Git servers, like Bitbucket.

How to Set Up a Repository 🛠️

There are different version control tools available 🌐. First, create an account on any platform. Here, I use GitLab, which is similar to GitHub 🖥️.

After making an account 📝, we need to connect the Git client with the remote platform 🌐. This involves authenticating GitLab to enable pushing changes from the local repository 💻 to the remote repository 📂. For this, we can set it up by adding an SSH key 🔑.

After doing this 🔑, GitLab can authenticate us when pushing or pulling from the repository 🔄. You can check the next steps to clone the repository 📂⬇️.

Work with Git ✨

There are mainly 3 stages 🛠️:

Working directory 📝: Where new files are created.
Staging area 📂: This represents that files are ready to push. Use git add to get the file in the staging area so it can be committed.
Local repository 💾: Here you can commit the changes. This is your system on which you are working.

I am creating a basic file to show how we work with Git. I create a README.md file 📄. After creating, type the command git status. This command shows the current status of the local Git repository 📊.

After that, we use the command git add . to move the file to the staging area. Then, type the git status command. It will show the file in green color ✅, which means that the file is in the staging area. Now it can be tracked.

It's time to commit the changes 🎉. Use the command git commit. Here is the screenshot of the commands I have used 📸.

Now it is time to push the work to remote repository that is on GitLab. Simply just write the command git push in the terminal it will do the work.

Note:- If you stuck and getting error I suggest use StackOverFlow or use ChatGpt to resolve the issue.

Initializing a Repo 🛠️

If you have worked on your project locally and you want to push it to your GitLab account 🐙, there is a way to make that happen.
You need to make that folder a Git repository 📁. Use the command git init to initialize a Git repo. Now follow the same steps above.

But you might notice there is an error while pushing the code 🚨. This happens because there is no destination defined. To fix this, create a repository on your GitLab account 🛡️. After creating it, you will see a section "Push an existing folder" 📋. From there, copy the git remote add command and paste it into your terminal 💻.

However, you might still get an error related to the master branch ⚠️. To resolve this, use the command showing in your terminal: git push --set-upstream origin master 🔗. Now the branch is connected too ✅.

Branching Concepts 🌿

The Master Branch 🛠️ is known as the main branch. It is created by default when you initialize a Git repository. New features, bug fixes, and stacks of changes in the master branch help divide the work among developers by creating a branch for each feature ⚡.

How to create a new branch? 🤔
The best practice is one branch per bugfix or feature 🐛✨. Developers can commit without worrying about breaking the main branch 🚀. Once changes are complete, merge the branch 🛡️. Then, a new version can be released 🎉.

However, large feature branches 📏 that stay open for too long increase the chance of merge conflicts ⚠️. By having separate branches, the main branch remains stable ✅.

The git pull command is used to refresh new changes in the remote repository 🔄. To switch between branches, use the command git checkout <branch name> 🔀.

To create new branches in the CLI 🖥️, first type git checkout master to switch to the master branch. Then, create a new branch by using the command git checkout -b <branch name> 🆕. This command will create a new branch and automatically switch you to it 🚀.

However, this branch exists locally only 🗂️ and does not replicate in the remote repository 🌐. To sync it with the remote, make changes, commit those changes, and use the command:
git push --set-upstream origin <branch name> 🔗.

Note 📝: In a project, there are typically two branches:
Master branch 🛠️ (main branch).
Develop branch ⚙️ (ready for production).

Merge Requests 🔄

Merge requests are typically done by other developers 👨‍💻👩‍💻. Afterward, experienced team members 👓 review the code before merging the changes.

This process ensures that the master branch 🛠️ remains stable ✅.

Deleting Branches 🗑️

After completing work on a branch, it’s a good practice to delete it 🧹. Branches can be deleted in two ways:

Through the remote repository 🌐:
Simply go to the branches section in your account and delete the branch 🖱️.
From the local environment 🖥️:

First, switch to the master branch and pull the latest changes:
git checkout master && git pull 🔄.
Then, delete the branch locally using the command:
git branch -d <branch name> 🗂️.

Rebase 🔄

Imagine you’re working in a bug-fix branch 🛠️ and have made some changes. At the same time, another developer also makes changes in the same branch 🔀 or in the remote repository 🌐. The changes made in the remote repository won't be reflected in the local repository of the first developer and vice versa.

In this scenario, Git will show that there are some changes. First, you need to pull those changes ⬇️ and then push your own changes ⬆️. This could result in multiple commits being pushed, which is not a best practice ⚠️.

To solve this, use the command:
git pull -r🔗.
This command rebases the changes, stacking your commits neatly on top of the latest remote changes 📚.

.gitignore File 📄

When you work on a project in your local environment 🖥️, certain files are generated, such as dependencies, build files, and other temporary files ⚙️. To exclude these files or folders from being tracked by Git 🛠️—especially those specific to your editor—you can use a .gitignore file 🚫.

For example, in build folders where compiled code is located 🏗️, you can create a .gitignore file and list those files or folders to prevent them from being tracked. This keeps your repository clean and focused on important files ✅.

./idea/*
/build/*
/node_modules/*

To stop tracking a file use command git rm --cached <folder name>.
To revert commits use command:-

git reset --soft Head~1
git commit --amend
git push --force
git revert <commit id>

And git merge 🔄 merge the changes from the master branch 🛠️ to another branch 🔀, make sure that your local master branch 🖥️ is up-to-date ✅ for that use git checkout master, git pull, go back to your branch 🔁 git merge master 🔗.

Resources 📚🌐💡

How to make ssh keys Link
Git Cheat Sheet Link

Conclude ✅🔚✨

In this blog, I’ve covered the basics of Git 🧑‍💻, but there are still plenty of concepts I couldn't cover 📚. Git is a vast tool with much more to explore. In my next blog, I will dive into build tools 🔧, starting with npm for JavaScript and Maven and Gradle for Java applications ☕. Stay tuned for more! 🚀

🌱 How to Set Environment Variables in Linux

Prashant Pal — Mon, 28 Oct 2024 12:25:43 +0000

🌐 Each user has their own system configuration, like which 🖥️ browser is set as default, which 🔧 shell is set as default, etc. 👤 Users can configure their system environment according to their needs. Environment Variables are used to store user environment information.

1.📝 The information in environment variables is represented in form of KEY = VALUE pairs, for eg. SHELL=/bin/bash.
Here SHELL is the name of the variable and /bin/bash is the value.

The environment variables are available for whole environment 🌍.
Remember name of all variables should be uppercase 🔠.
You can change environment variables values accordingly 🔄.

How to see env in CLI 🐚

To print env variables there is command printenv that prints all env variables SHELL, HOME, USERNAME, LANG etc 🖨️✨.

You can print specific env variable by typing the variable name, for eg. printenv USER 🖨️. You can also use pipes and grep command to find similar variable name 🔍🛠️.

🌱 Creating Own Environment Variables

🌟Why to create own environment variables,

🔒To protect sensitive data for an application. When the application needs to run on servers it needs credentials to access. You can use environment variables to store those user name and password.
By this application becomes more flexible 🔄.

Now lets create:-

export is used to create a env variable, for eg:-

2.🚫 To remove the variable we use unset.

NOTE:- 📌 Using export command to make variable is only available in current session. Once the CLI is closed all variables are gone.❌

🌍 How to set env permanently

There is a file called shell specific configuration file. It is set according to user default shell. For eg. if you are using BASH, you can declare the variables in the ~/.bashrc file.

📝 Open the file with vim, vim .bashrc and then type the variables you want to add. Syntax for adding the variable is same as we have discussed above. And after adding 🔄 the variables to .bashrc file you need to refresh it by typing the command source .bashrc.

📚Resources

Conclusion

Setting environment variables in Linux is a powerful skill that can significantly enhance your development and system administration tasks. 💻 We discussed how to create, modify, and remove these variables 🚀.

If you have any questions or tips to share about working with environment variables, please leave a comment below. 💬 Thank you for reading, and happy coding! 🌟

You can check this on hasnode too.🥰 https://prashantsdevlog.hashnode.dev/

In this week I'll learn networking skills in linux essential for a DEVOPS engineer. 🤗

BASH(Shell) Scripting 101

Prashant Pal — Sun, 20 Oct 2024 17:41:29 +0000

Let's Start 🚀

In this blog, I’ll be explain the basics of Bash scripting—a powerful tool for automating tasks and managing system operations. Well this is what I learned but I try my best to explain it here.📚

When we write commands in a file, and we use that file to execute, thus making it moveable that file is called shell script. It has .sh extension 📂.

Advantages Of Shell Scripting🌟

You can avoid repetitive work.🔄
You can keep history of configuration.📜
Share the instructions.🤝
You can handle logic and bulk operations.⚙️

There are different shell implementation:-

sh:- Bourne Shell /bin/sh 🐚
Bash:- Bourne again shell /bin/bash. Bash is a shell program. Bash is a programming language.💻

Shebang line is used to tell which language you would use. You need to write it in your file in order to use it. Syntax to write shebang line :- #!/bin/bash for eg. here I use bash.📜

To run the file we use,

./filename.sh

But this will not execute because you have no permission to execute, and now we will use our permission knowledge to give permission to that file. I have mentioned in my previous blog how to give permission to a file take a reference from there. And don't forgot to use sudo.🔑

Now make some variables. It is similarly to other programming languages. Here is the syntax:-

variable_name=value

To use the variable type $variable_name. To store the output of a command in a variable use variable_name=$(command).📦

Conditionals⚖️

You all are familiar with conditional statements while learning programming language.

if :- Syntax for using if [..built_in_commands..]
else :- Syntax for using else ....

You see there is then when you write condition in if statement next step is to set instructions for that we use then then type something. After that we use else. And at the last we use fi to close the statement.

Operators⚙️

In bash there are different types of operators:-

Arithmetic Operators:- Basic mathematics operators, similar to other programming languages (+,-,*,/ etc). I think its pretty basic.
Relational Operators:- These are used for comparisons. There are various types:-

-eq Equal to
-ne Not equal to 
-lt Less than
-le Less than or equal to 
-gt Greater than
-ge Greater than or equal to

String Operators:- These are for strings.

= Equal
!= Not Equal 
-z String is null
-n String is not null

File Test Operators:- These are used to test various properties associated with a file.

-e Checks whether file exist or not 
-d Checks whether file is a directory
-f File is a regular file
-r Checks whether file is readable
-w Checks whether file is writable

There are other operators too but I thinks these are the most common till now.

Passing Parameters📨

Well in simple words, when you type something in CLI then it can be used inside the bash scripts. And to make this possible we use $ sign.

$ sign:- So this starts from 0 to 9 and uses special character too.

$0 Basically used for naming
$1-$9 These are used to store the passed i/p at CLI
$@ Represent all the parameter passed to the script
$* Represent all the argument in a single string 
$# Represent total number of arguments provided

There are other advance method too, you can learn them but its better when you need to use them.

Loops🔄

Similar to programming languages there are different types of loops. For example:- while, for, until, select.

1.For Loop:- Syntax of for loop:-

Output

In syntax you notice do and done. Do indicates that execute the commands until the condition is satisfies, and done indicates that loop is over.

Note:- For arithmetic operators use double brackets (()). And while creating your .sh file don't forgot to give your file necessary permissions.🔑

2.While Loop:- Syntax of while loop:-

The do and done have the exact same function as in for loop.

3.Until Loop:- Opposite of while loop. Syntax of until loop:-

until [ condition ]; do
    # Commands to be executed
done

4.Select Loop:- It creates a simple list from the given options. Syntax of select loop:-

select var in list; do
    # Commands to be executed
done

Functions

We use functions in every programming languages, and here it is same work as in other languages. Better overview of codes, reuse code again, etc.

Syntax of functions:-

function name_function {
----logic----commands---
}

name_function(){
---logic---commands---
}

How to call a function, its simple type the function name for example:-

greet() {
    echo "Hello, $1!"
}

greet "Prashant"

And the same example can be used to show how to pass the values to a function.

To return the value in a function we use $?, it holds the return value of the function or last executed command.

Resources📚

Refer to this site to deepen your knowledge in bash. But as I say always don't learn whole at one go, learn as you grow/move.🌱https://www.javatpoint.com/bash-introduction
For revision https://www.youtube.com/watch?v=I4EWvMFj37g.
You can refer for more topics like AWK Arrays SED etc https://www.youtube.com/watch?v=tK9Oc6AEnR4

Note:- AWK is important just watch it.👀 I have seen some interviews where interviewer asks about AWK command. So just watch it. It is easy topic.

What I've Learned About Bash: A Beginner's Perspective🌟

Learning the basics of Bash scripting has been an exciting journey, and I hope this blog helps you on your own path. While there's always more to discover, mastering these fundamentals is a great start. 🚀

In my next blog, I’ll explore environment variables, how to create them, networking concepts, and SSH.🌐

Feel free to share your thoughts or questions in the comments—I’d love to hear about your experience!💬

This blog is also on hashnode, you can check it out.
https://prashantsdevlog.hashnode.dev/

Manage Permissions In Linux 🔐

Prashant Pal — Mon, 14 Oct 2024 12:25:10 +0000

This week, I explored🔭 two essential aspects of working with Linux: managing permissions 🔐 and getting comfortable with the Vim editor ✍️. Both are crucial for anyone working in a Linux environment. Let’s break down what I’ve learned 😇.

VI & VIM Editor

VIM is a built in editor in Linux. Well we have VS Code and editor to edit or create file, why we use VIM.

For small modifications🔧 it is faster especially when working in CLI.
Faster to create and edit at the same time⏰.
It Support Multiples formats
While working on remote servers it is very useful.

To open file with VIM write this command in CLI

vim <file_name>

VIM have two modes📕 Command Mode and Insert Mode:
Command Mode :- This is the default mode. In this you can't edit the text. But you can navigate, search, delete, undo etc.

Insert Mode :- This mode allows you to enter text, edit text etc.
To switch to insert mode press i key.

After adding some text you need to save and exit the editor, for that simply press esc key. Then type :-

:wq!

This command writes the file to disk and quit vim editor.
To quit vim without saving the changes then type :-

:q!

In a file to remove whole line you can use command dd this delete entire line. To delete🗑️ multiple line then use type d20 here 20 means number of lines, you can just count the lines from where you want to delete. For Undo type u. To jump to a specific line use command 16G here 16 is line number. To search use /pattern.

Note:- When I say command then it should be written in command mode only. Commands don't work in Insert Mode.

NANO Editor

Nano is more user friendly than vim. To make file or to open file use command :-

nano filename

This opens nano editor. You can see various commands at the end of the editor use these to navigate through it. I recommend to use all commands and try out every one.

Managing Permissions 🔒

In a linux system there are 3 user👤 categories:-

Superuser Account🦹🏻‍♀️:- In this root user have unrestricted permissions. For administrative tasks you need to login as root user.
Regular User Account🙋🏻‍♂️:- A user we create to login into the system. For eg. /home/pal.
Service user🚹:- It is relevant for Linux Server Distributions.

How To Manage permissions? There are two levels first User Level and second is Group Level. In User Level we give permissions to user directly. In Group Level we group users into linux groups and then give permission to that group.

All users information is stored🏪 in /etc/passwd. This stores user account information. Everyone can read it, but only root user can change the file. After running🏃🏻 this command you will get information of the user,

pal:x:1000:1000:pal,,,:/home/pal:/bin/bash

The above line represent this:- USERNAME:PASSWORD:UID:GID:GECOS:HOMEDIR:SHELL

To create new user, use command

sudo adduser<username>

It automatically chooses UID and GID values and creates a home directory for new user. After running this command enter new password and other details.

To change the password of user

sudo passwd<username>

To login to this username use su-.
To add group use this command:-

sudo groupadd<groupname>

By default, the system assigns the next available GID 🔢.

You noticed that we can write the command adduser as useradd, so what is the difference between adduser and useradd, and similarly groupadd and addgroup? 🤔

adduser & addgroup ➡️ These are more interactive 💬, more user-friendly 😊. It is easier to use and automatically chooses UID and GID values itself. Use these commands when you are executing manually 🖱️.

useradd & groupadd ➡️ In these commands, you need to provide the information yourself 🛠️. These commands are used when executing in an automated way 🤖.

To change a user's group to another group, use:

sudo usermod[Options]<username>

There are various tags use linux man page to access all tags related to usermod command or you can use google to search it.

To delete group use

sudo delgroup <groupname>

Ownership And Permissions 👤🔑

In simple words ownership means who owns the file or who have access to that file. Owner is the user, who created the file, and owning group is the primary group of that use. To change the ownership use command

sudo chown <username>:<groupname> <filename>

To understand it better lets use this command ls -l. This shows long view of the directory.

I'll take drwxrwxr-x 2 pal pal as a example your terminal should have this type of oputput.

d :- This is the file type. There are are different file types. "-" is for regular file, "d" is for directory, "c" is for character device file, "l" symbolic link, etc.
rwx :-First group of rwx is for owner. This indicates owner have access to this file, "r" stands for read, "w" stands for write, "x" stands for execute, "-" stands no permission.
rwx :- Second group of rwx is for group owner.
r-x :- This is for all other users, who are not the file owner or don't belong to the group owner.

Note - If "-" is used in place of rwx it means anyone is missing, don't have permission. For example r-x in this w is missing and instead of w, "-" is used this means it don't have permission for write.

To remove permission use, here - stands for removing the permission and g stands for group.

sudo chmod g-w <filename>

To add permission use, here + stands for adding the permission. For user use u instead of g.

sudo chmod g+x <filename>

Note 📝: You can use the absolute numeric method to give permission. You can search it on Google 🔍. For each number, there is a permission assigned, for example, 7 is for rwx.

Resources 📚

If you want to access the Linux terminal online, use this website: https://bellard.org/jslinux/ 🌐
Use ChatGPT 😉 to explore more. 🤖

Wrapping Up And Getting Ready for Another Learning Adventure 🌟

Last week, I took a deep dive into managing permissions in Linux 🔐, mastering the Vim editor ✍️, and learning about access controls 🛡️. Each of these topics has given me a strong foundation in how Linux handles file security and text editing. I know this will be helpful when I set up my remote VM for my DevOps projects 💻.

In this week, I’m excited to explore shell scripting 🐚 and networking in Linux 🌐! Shell scripting will open up new possibilities for automating tasks 🔄 and making my workflow more efficient, while understanding Linux networking will give me the knowledge to configure and troubleshoot connections in various environments 🛠️.

Stay tuned for more Linux and open-source adventures next week! 🚀

You can check my blog on hashnode too.

My First Week With Linux

Prashant Pal — Mon, 07 Oct 2024 17:41:07 +0000

I started learning📖📖 Linux last week. It's been exciting🤗 and a bit overwhelming as I've explored file systems, the terminal, and basic commands. Here's what I've learned so far.

Linux File System

Linux have hierarchical tree🌲 structure. There is one root folder and in that folder there are other different folders. Each folder contains different files. Here is the list of folders:

/home:- This folder contains home🏡 directories of all non root users.
/bin:- Binaries, contains executables for most common user commands.
/sbin:- System Binaries, contains system relevant files/programs that admin use (super use privilege).
/lib:- Library📚, contains essential shared libraries that files/programs from /bin and /sbin use.
/usr:- User👤, this is used for user home directories.
/opt:- Optional, contains 3rd party programs you install.
/boot:- Booting, contains files required for booting.
/etc:- Etcetra, contains configuration for system apps.
/dev:- Devices, location for device files like webcam, keyboard, etc.
/var:- Variable, contains files to which the system writes data during the course of its operation.
/temp:- Temporary, contains temporary resources required for some process.
/media:- Removable media.
/mnt:- Mount, temporary mount points.

Note:- "." is used for hidden files and folders.

I'm not saying that I learn these, its for just understanding like whats inside that folder. This is only for reading.

Linux Terminal And Basic Commands

When I opened the terminal it shows "pal@pal-ubuntu:~$" so I searched about it and here's what i learned.

pal:- First is username. It shows your username in my case its pal.
pal-ubuntu:- Second is computer name. It shows your computer name in my case its pal-ubuntu.
::- It is separator.
$:- It represent regular user, # is used for root user.

For basic commands I make sure to learn📕 those only which are mostly used. It's better to type commands in terminal on your own and experiment it. Don't learn all commands at once because it makes no sense. Learn as you go😇.

pwd:- Print working directory. It shows current directory.
ls:- List. It shows the list of files inside a directory.
cd:- Change directory. It helps in navigating from one directory to another.
mkdir:- Make directory. Make folder.
touch:- Create files.
rm:- Removes files/folders.
clear:- Clears the terminal.
mv:- Move flies or used to rename it.
cp:- Copy files.
cat: Displays the file content.
sudo:- Allows regular users to run programs with the security privileges of the super use or root.

Note:- There are different tags with some commands for eg. ls,rm,mv,etc. I learn them simply by searching it on google and take help from ChatGpt. I suggest experiment those commands with all tags to get better understanding of how command works.

Now Time To Install Apps

After having some terminal knowledge I want to install apps for my new os because its too empty😅. In linux there are different types of package manager, for ubuntu by default there is apt(Advanced Package Tool).

sudo apt search:- To search the existing package.
sudo apt update:- To update the package.
sudo apt install:- To install the package.
sudo apt remove:- To uninstall the package.

Note:- For limited view on screen while installing the package you can add get eg. sudo apt-get install this will show limited view. But apt is more user friendly.

Well there is more, you can install packages by different ways. First one I have discussed above, second is by using default store in Ubuntu, and the third one is snap. Snap is a bundle of app and its dependencies. Snap store provides a place to upload snap.

Important thing is snap takes more space on disk and its third party which means you should be careful while using it.

Resources

Here is some articles which I read -

You can search videos on youtube but I think reading helps you a lot, but it takes time.

It Continues.....

After one week of learning Linux, I feel much more comfortable😌 with the terminal, file systems, and package management. While I still have a long way to go📈, this foundational knowledge is making Linux feel less intimidating every day.

In the coming week, I plan to dive🤿 deeper into shell scripting and understanding permissions in Linux. I’m excited to see how these building blocks will help me automate tasks and manage my system more efficiently.

Well I want to start my Devops journey and I think this is the starting point of it. I can't give too much time to learn linux, but I can learn it more deeper while doing real projects and challenges that will I face.