In today' s ever-changing world of technology, one thing stands firm as a symbol of efficiency, flexibility, and control: the Linux terminal. If you're venturing into the complex realm of DevOps or in Backend Development, learning Linux terminal commands is like having a potent tool that can revolutionize how we create, release, and oversee software.

Before delving into the world of Linux commands and how to use them, let's start by understanding what Linux is.

What is Linux?

Linux is an open-source, Unix-like operating system kernel that serves as the core component of many different Linux distributions or "distros", like Ubuntu, CentOS, Debian, Arch Linux and many more.

In 1991, Linus Torvalds originally crafted Linux, and over time, it has grown into a highly regarded and impactful operating system kernel. Renowned for its stability, security, and scalability, Linux finds applications across diverse computing environments, spanning from servers and supercomputers to desktop computers and embedded systems.

Linux provides users with a versatile command-line interface (CLI) known as the Linux terminal. The Linux terminal, a versatile command-line interface (CLI), empowers users to perform a wide range of tasks, including file management, system configuration, software installation, and automation, all through text-based commands.

Let's now delve into a variety of Linux commands.

Linux Commands

To run a range of Linux commands, simply open your terminal or shell.

To access a Linux Terminal on your PC, you may have several options:

Linux Distribution (Distro) like Ubuntu: Install a Linux distribution alongside or instead of your current operating system. Ubuntu is a popular choice for beginners.
Virtual Machine: Set up a virtual machine using software like VirtualBox or VMware, which allows you to run Linux within your existing OS.
Windows Subsystem for Linux (WSL): If you're using Windows 10 or later, you can enable WSL to seamlessly integrate a Linux shell into your Windows environment.

Basic Commands

pwd: In the terminal type:
```
  pwd
```

pwd command prints the full name of the current/working directory.

mkdir: Let's create a folder in the current working directory. To do this, we use the mkdir command. Let's create a folder named test. In your terminal, type the following command and press Enter:
```
  mkdir test
```
cd: Now, let's move into the folder test we created. We use the cd command to do this. The cd command changes the current working directory to the specified directory. To use this command, type cd followed by the directory you want to move to.
```
  cd test
```
touch:To create new files, we use the touch command. Let's say we want to create a file called names.txt in the test directory. To create the file, type:
```
  touch test.txt
```
ls: Let's see if the file names.txt is created or not. For this, we use the ls command; this command lists all the contents (files and folders) present in a directory.
```
  ls
```
If you want to see the contents of a folder without changing the directory, you can type the ls command followed by the folder_name:
```
  ls folder_name
```
There are various options that come with the ls command:
- ls -a shows all the files and folders, including those that start with .
- ls -u shows the newest files first
- ls -l shows files and folders in a long listing format

Text editors: vim and nano are two commonly used text editors in Linux terminals, both used to create and edit file contents. To open a file in the nano text editor, we can simply use the command:

nano test.txt

Now to write content in your test.txt file.
After writing the content in your file, simply press ctrl + X to save and exit from the file. After that it will ask, do you want to save the modified buffer(or to save the modified cahnges), simply press y to save the modified changes.
Nano text editor comes with various shortcut command that helps in reading, editing and writing contents of a file easier. For example, by pressing ctrl + / and writing line number and column number, you can jump to that specific section of that file.
There are more features and shortcuts in nano text editor. You can follow this pdf for a list of commands.
Let’s discuss about vim text editor:
To open a file in vim, we can use the command:
```
  vim test.txt
```
Now to write content in your test.txt file, there is an insert mode/editing mode so that you can write or edit the changes in your file. To use the insert mode just simply in your keyboard, press esc button and then press i button to enter the Insert Mode. Now you can write or edit in your text file.
After writing or editing, it's time to save the project.To save this project again press esc and write :x or :wq . This will save your project and safely exit it from the file.
There are various commands you can use in vim. You can follow this pdf for a list of commands.

Some Other Commands

cat : This command is used to display information of a particular file.
```
  cat test.txt

  Output: This is a text.txt file
```
cp : Used to copy file.

E.g: cp <file name> <path_where_you want_to_paste_the_file>
```
  cp text.txt ~/new_folder
```
mv : Used to move the file from current path to another path.

E.g: mv <file name> <path_where_you want_to_paste_the_file>
```
  mv /new_folder/text.txt ~/folder/test
```
rm : Used to delete the file.
```
  rm test.txt
```
rmdir : To delete a folder.
```
  rmdir new_folder
```
rm -rf : Used to forcefully delete a folder.
```
  rm -rf folder/test
```
whoami : This command is used to display which user is logged in.
```
  whoami

  Output: linux
```

ping : You can use ping command for checking the connectivity and reachability status of the Ip network.

ping google.com

wget : This command is used to download files from the internet.

wget http://example.com/sample.php

There are multiple options available in wget command:

Sytax	Description
wget -o logfile [URL]	Direct all system-generated messages to the specified logfile. If no logfile is specified, messages are redirected to the default logfile (‘wget-log’).
wget -a logfile [URL]	Append output messages to the current output logfile without overwriting it. This preserves the log of previous commands, with the current log appended after them.
wget -i inputfile [URL]	Read URLs from a file.
wget -b <url>	Runs the download process in the background

What is Root?

Root is like a super-user account in the unix based system and is used for giving administrative privileges to the user and has the highest number of access rights in the system. sudo command is used to give adminitrative privilages to the user

Some folders and files can only be accessed when give root privilages to the user. For example, /etc directory contains system configuration files, many of which require sudo to modify.

To get into the root environment you can use sudo su command but to access the root environment you’ve to give user password.

sudo su

To access any file or folder which requires root privileges you’ve to start by writing sudo:

sudo vi /etc/resolv.conf

Here also you’ve to give user passwaord to change or access the file.

Adding a new user in linux

useradd: It is used to add a new user in linux.
```
  sudo useradd New_user
```

Here also when creating a new user you have to use sudo to run the command using root privileges.

passwd: It is used to create or modify a new password for the new user.

passwd New_user

userdel: This command is used to delete a user.

userdel New_user

File Permissions in Linux

Setting up file permissions in linux are a fundamental aspect of the system's security model, determining who can read, write, or execute a file or directory. Every file and directory has an associated set of permissions, which are applied to three categories of users:

Owner: The user who owns the file.
Group: A group of users who can share access.
Others: Everyone else on the system.

Understanding File Permissions

When executing the ls -l command display a permission format in the terminal.

-rwxr-xr--

This can can be broken down into four parts:

File Type: The first character - means it’s a file. Some common values in the file type includes:
- - for a regular file,
- d for a directory.
Owner permissions: The next three characters(rwx) represents the permissions for the file owner. These permissions apply exclusively to the individuals who own the files or directories.
- r : read permission, that means owner of the file can read the contents of the file.
- w : write permission, means that owner can also change or add the contents of the file.
- x : execute permission, means owner can execute the file.
Group permissions: Permissions can be assigned to a specific group of users, impacting only those within that particular group. The following three characters (r-x) represent the permissions for the group.
- r : read permission,
- - : no write permission,
- x : execute permission.
Others permissions: The final three characters (r--) apply universally to all users on the system.
- r : read permission,
- - : no write,
- - : execute permission.

Changing File Permissions

chmod known as ‘change mode’ command allows us to modify the file permissions. Permissions can be changed using symbolic or numeric (octal) modes.

Symbolic: You can use letters to modify permissions:
- r: Read,
- w: Write,
- x: Execute

Example:

chmod u+x test.txt

The above command add execute permission for the owner.

chmod g-w file.txt

The above command add execute permission for the group.

Numeric: Permissions can also be set using numbers (0–7). Each digit represents a combination of read (4), write (2), and execute (1) permissions:
- 7: Full permissions (rwx),
- 6: Read and write (rw-),
- 5: Read and execute (r-x),
- 4: Read only (r--).

    chmod 755 test.txt

The above command, owner has rwx, group and others have r-x.

Changing Ownership

To change the ownership of a file or directory, use the chown command. This command allows you to specify a new owner and group for a file.

chown newuser:newgroup test.txt

This command change the owner and group.

Conclusion

In conclusion, mastering Linux terminal commands is an essential skill for anyone involved in DevOps, backend development, or any technical field that requires efficient system management. The Linux terminal offers a powerful interface for performing a wide range of tasks, from basic file management to complex system configurations. By understanding and utilizing these commands, users can enhance their productivity, streamline workflows, and gain greater control over their computing environments. As you continue to explore and practice these commands, you'll unlock the full potential of Linux, making it an invaluable tool in your technical toolkit.

Introduction to Linux Terminal Commands

Table of contents