Linux Interview Guide: 100+ Q&A for 2025

Default ports used for:

SMTP (Simple Mail Transfer Protocol):

• Port: 25
• Used for sending email.

DNS (Domain Name System):

• Port: 53
• Converts domain names to IP addresses.

FTP (File Transfer Protocol):

• Ports: 20 (Data), 21 (Control)
• Used for file transfers.

DHCP (Dynamic Host Configuration Protocol):

• Ports: UDP 67 (Server), UDP 68 (Client)
• Assigns IP addresses automatically.

SSH (Secure Shell):

• Port: 22
• Provides secure remote access.

Squid (Proxy Server):

• Port: 3128
• Acts as an intermediary for web requests.

To lock a user account in Linux, you can use the 'passwd' command with the '-l' option, followed by the username. This will lock the specified user account.

sudo passwd -l username

The 'ls' command is used to list files and directories in Linux. It provides information such as permissions, ownership, size, and modification time of the files/directories in a specified location. To display hidden files and directories, you can use the '-a' or '--all' option with the 'ls' command. For example, ls -a or ls --all will show both visible and hidden files and directories in the current directory.

ls /path/to/directory

The 'tail' command is used to display the last n lines of a file in Linux. By default, it shows the last 10 lines of a file.

tail -n <number_of_lines> filename

To display the last 10 lines of a file using 'tail', you can use the following command:

tail -n 10 filename

The 'grep' command is used for searching patterns in files. It can be used to extract lines that match a specific pattern or regular expression.

grep "pattern" filename

You can use the following command to search for a specific word (e.g., "search_term") in a single file:

grep "search_term" filename

The 'ps' command is used to display information about the running processes in Linux. By default, it shows the processes of the current user.

You can use the ps -e --forest command to display processes in a hierarchical tree-like structure, showing parent-child relationships between processes.

The 'env' command is used to display the current environment variables in Linux.

You can use the 'env' command to unset an environment variable by setting it to an empty value. For example, to unset a variable named 'VAR_NAME,' you can do the following:

env VAR_NAME= your_command

The 'top' command is used to monitor the system in real-time. It provides a dynamic view of the processes running on the system, sorted by their resource consumption.

You can start the 'top' command by opening a terminal and simply typing 'top' and pressing Enter. To customize its behavior, you can use various command-line options. For example:

The 'netstat' command is used to display network connections and routing tables. It provides information about active network connections, listening ports, and various network interfaces.

To view all established connections, you can use the following command:

netstat -tuln | grep 'ESTABLISHED'

This command lists all established TCP connections.

The 'lsof' command is used to list open files and the processes that have opened them. It can also display network connections, file descriptors, and other related information.

You can typically install 'lsof' on a Linux system using your system's package manager. For example, on Debian-based systems like Ubuntu, you can use the following command:

sudo apt-get install lsof

On Red Hat-based systems like CentOS or Fedora, you can use 'yum' or 'dnf':

sudo yum install lsof

The chmod command in Linux is used to change the permissions of a file or directory. chmod stands for "change mode." The command allows you to set permissions for three different types of users: the owner of the file, the group that the file belongs to, and all other users.

The chmod command uses a combination of letters and numbers to set permissions. The letters 'r', 'w', and 'x' represent read, write, and execute permissions, respectively. The numbers 4, 2, and 1 are used to calculate the total permissions for each user type.

For example, chmod 752 filename will give the owner read, write, and execute permissions, the group read and execute permissions, and all other users read permissions.

The chown command in Linux is used to change the ownership of files and directories. It allows you to transfer the ownership of a file or a directory from its current owner to a new owner. In order to use this command, you must be the owner of the file or directory, or you should have root privileges. The syntax of the command is chown [user][:[group]] file, where the user is the new owner of the file and :[group] specifies the group to which the file belongs. If you omit the group, the file will be owned by the user specified and the file's group will remain unchanged. The chown command is a powerful tool that can be used to manage file permissions and access rights.

The cp command, short for "copy", is a command in Linux that allows the user to create copies of files and directories. This command can be used to duplicate a single file or an entire directory of files, and can be done either within the same location or between different directories. Additionally, the cp command can be used to preserve file attributes such as timestamps, permissions, and ownership. The cp command is a fundamental tool in Linux, commonly used in everyday tasks and administrative tasks, making it a key command for anyone who works with Linux systems.

To remove a file or directory in Linux, you can use the command "rm". To remove a file, you can use the command followed by the name of the file you want to delete. For example, "rm filename.txt" will delete the file named "filename.txt". However, if you want to remove a directory, you need to add the "-r" flag to the command to remove the directory and all its contents. For example, "rm -r directoryname" will delete the directory named "directoryname" and any files or directories it contains. Note that these commands can permanently delete files and directories, so use them with caution.

mkdir stands for "make directory" and is a command in Linux used to create new directories (or folders) within the file system. When you execute the mkdir command followed by a directory name, it creates a new directory with that name in the current working directory. You can also specify a complete path to create a directory in a specific location.

For example, mkdir /home/user/documents would create a directory named "documents" within the "user" directory, which is inside the "home" directory. mkdir is a simple but useful command for organizing and managing your files in Linux.

The rmdir command in Linux removes an empty directory from the file system. It is a simple command that only requires specifying the name of the directory to be removed. This command does not work for removing a directory that has contents in it as it will trigger an error.

The syntax for the rmdir command is rmdir [option(s)] directory_name. Some useful options that can be used with the command include -p which allows the removal of parent directories, and -v which enables verbose output.

Overall, the rmdir command is a handy tool for quickly cleaning up empty directories on a Linux system.

To exit from the vi editor, you can use the following steps:

• Ensure you are in the command mode by pressing the Esc key.
• Type :q and press Enter to quit vi if you have not changed the file.
• If you have made changes and want to exit without saving, type :q! and press Enter.
• To save any changes you have made and exit, type :wq and press Enter.
• If you are experiencing difficulties or want to exit without saving changes, you can also force vi to quit by pressing Ctrl + C twice in quick succession.

To delete information from a file using vi, you can use the "delete" or "yank" commands. To delete a single character, move the cursor to that character and press the "x" key. To delete an entire line, move the cursor to the line and press the "dd" keys.

If you want to delete multiple lines, press the "Esc" key to enter command mode, then type the range of lines you want to delete followed by "dd". For example, to delete lines 5 through 8, type "5,8dd" and press enter. To undo a deletion, press the "u" key.

Here are some common Linux commands to manipulate and view file content:

• cat: Concatenate and display file contents.
• head: Display the first few lines of a file.
• tail: Display the last few lines of a file.
• less: View file contents page by page.
• grep: Search for specific patterns in a file.
• wc: Count the number of lines, words, and characters in a file.
• sed: Stream editor for filtering and transforming text.
• awk: Text processing tool for manipulating and extracting data from files.
• cut: Cut out selected portions of a file.
• sort: Sort the lines of a file.

Here are some of the most popular Linux Distributions (Distros) along with their usage:

• Ubuntu: This is one of the most popular Linux distros and is known for its user-friendly interface. It is used for personal use as well as servers.
• Debian: One of the oldest Linux distros, Debian is known for its stability and reliability. It is typically used for servers and workstations.
• Red Hat Enterprise Linux (RHEL): One of the most widely used Enterprise Linux distros, it is designed for mission-critical systems. It is often used in corporate environments where stability and support are crucial.
• CentOS: This open-source community-based distro is known for its stability, security, and long-term support. It is commonly used for servers and web hosts.
• Fedora: This is a community-based version of Red Hat that offers newer versions of software than RHEL5. It is a popular choice for developers and has a shorter release cycle than RHEL.

Here is a simple Bash script that checks if a user exists on the system:

You can save this script in a file, for example check_user.sh. Then, make the file executable by running chmod +x check_user.sh. Now you can run the script by executing ./check_user.sh and it will prompt you to enter a username. After entering a username, it will check if the user exists on the system and display a corresponding message.

Here's a simple Bash script that checks if a given process is running and prints a message accordingly:

To use this script, replace your_process_name with the actual name of the process you want to check. Save the script to a file (e.g., check_process.sh), make it executable using chmod +x check_process.sh, and run it using ./check_process.sh.

The script uses the pgrep command to check if the process is running by searching for its exact name. If the process is found, it prints a message indicating that it is running. Otherwise, it prints a message indicating that it is not running.

BASH (Bourne Again SHell) and DOS (Disk Operating System) are both command line interfaces used to interact with the operating system. However, there are some key differences between them.

• Syntax: BASH follows the syntax of Unix-like operating systems, while DOS uses a different syntax.
• Compatibility: BASH is primarily used on Unix-like systems such as Linux, while DOS is mainly used on Windows systems.
• Features: BASH offers advanced features like scripting, command substitution, and piping, while DOS has simpler commands and a limited set of features.
• File system: BASH supports a hierarchical file system, while DOS uses a flat file system.

In summary, BASH is more powerful and flexible, while DOS is simpler and more limited in functionality.

Internal commands and external commands are terms used in computing. Internal commands are built into the operating system of a computer, and are a part of its functionality. These commands are typically small, and help the user to perform basic functions like copy, move, and delete files. External commands, on the other hand, are programs or utilities that are not part of the operating system. They need to be installed separately, and offer a wider range of functions. External commands often provide additional functionality, such as compression or encryption, that is not available with internal commands. Overall, both types of commands are essential for users to perform various tasks on their computers.

In Linux, a PIPE is a mechanism that allows the output of one command to be supplied as input to another command. It is a form of interprocess communication that allows separate processes to communicate with each other without the need for intermediate files. The PIPE command '|' is used to create a pipeline that connects a series of commands. For example, if we want to take the output of the 'ls' command and then sort it alphabetically, we could use the command 'ls | sort'. This would take the output from the 'ls' command and pipe it to the 'sort' command for sorting. Piping is a powerful function in Linux that enables commands to work together in powerful ways.

In a computer system, a parent process and a child process can communicate with each other using various interprocess communication mechanisms. One common method is through pipes, which allow the parent and child to share data by writing to and reading from the pipe.

Another way is through shared memory, where both processes can access and modify a common memory region. Additionally, they can use signals to notify each other about specific events. The parent process can send a signal to the child process, and the child process can handle the signal to perform a certain action. Overall, these communication mechanisms enable effective coordination and information sharing between the parent and child processes.

A stateless Linux server is a type of server that does not retain any user-specific data or configuration settings. It operates without persistent storage, meaning that upon reboot, all previous data and settings are lost. This type of server typically relies on network-based storage, such as a network file system (NFS) or Internet Small Computer System Interface (iSCSI), to provide necessary files and resources. Stateless Linux servers are highly scalable and can be easily deployed and replicated. They are commonly used in cloud computing environments where quick provisioning and easy management are essential. By being stateless, these servers offer increased flexibility and simplicity in deployment and administration.
This configuration offers several benefits:

• Easy Scalability: Stateless servers can be easily replicated and deployed in a distributed system, ensuring high availability and load balancing.
• Simplified Maintenance: With no local data, it becomes easier to update or replace a server without impacting the system's overall functionality.
• Enhanced Security: Since there is no local storage, there is a reduced risk of sensitive information being compromised if a server is compromised.
• Streamlined Configuration Management: Stateless servers can be quickly and uniformly configured using automation tools, leading to improved efficiency and consistency in deployments.

To ensure data consistency and synchronization among stateless server instances in a distributed system, one can employ techniques like distributed databases, distributed caches, or distributed consensus protocols like Paxos or Raft. These approaches enable servers to share and update data in a coordinated manner, maintaining consistency even in the face of failures or network issues.

Additionally, versioning, timestamping, and conflict resolution mechanisms can help reconcile conflicting updates. Load balancers and service discovery tools can ensure clients connect to available instances. Regular data replication and periodic consistency checks further bolster data integrity, making the distributed system robust and reliable.

A Zombie Process is a type of process that has completed its execution but still has an entry in the process table. In other words, it's a process that has terminated, but its parent process has not yet received its status. This usually happens when the parent process fails to invoke the wait system call after its child has completed execution. As a result, the operating system cannot remove the entry from the process table, and the terminated child process remains in a zombie state as a dormant process. Zombie processes occupy system resources and can lead to performance degradation if not taken care of in time.

Zombie Processes, by themselves, do not cause performance problems or issues on a Linux system. However, if a large number of zombies accumulate and are not reaped by their parent processes, they can consume entries in the process table, potentially leading to resource exhaustion.

The Ctrl+Alt+Del key combination on Linux system is typically used to perform a system reboot or shutdown. However, this is not a default key combination on most Linux distributions. On Linux operating system, the Ctrl+Alt+Del combination can be configured through the systemd software suite. This suite provides a central management system for systems and service configuration. In order to configure this key combination, the user must create a custom systemd target file. Once created and properly configured, this key combination can be used as intended to initiate a system reboot or shutdown, working similar to the traditional means on Windows or other operating systems.

Here's a sample Linux script that lists all the files in a given directory:

To use this script, you can save it in a file, e.g., list_files.sh. Then, give it execute permissions by running chmod +x list_files.sh. Finally, you can execute the script by running ./list_files.sh /path/to/directory where /path/to/directory is the directory for which you want to list the files.

Yes, the 'tail' command allows you to specify the number of lines to be displayed. By default, it displays the last 10 lines of a file. However, you can change this behavior by using the '-n' option followed by the desired number of lines.

For example, to display the last 5 lines, you would use the command 'tail -n 5 filename'. This will show the last 5 lines of the specified file. You can adjust the number as needed to display a different number of lines.

Yes, it is possible to use the 'cat' command to create a new file or overwrite an existing file. To create a new file using 'cat', you can run cat > filename.txt and then start typing the content of the file. Press Ctrl + D to save and exit. This will create a new file with the specified name. To overwrite an existing file, you can run cat > existing_file.txt and then type the new content you want to overwrite with. Again, press Ctrl + D to save and exit. This will replace the content of the existing file with the new content you provided.

To perform a case-insensitive search using the grep command, you can use the -i option. By adding -i before the search pattern, grep will ignore the case of the letters and match both uppercase and lowercase versions of the pattern.

For example, to search for the word "example" in a file called "text.txt" without considering the case, you can use the following command:

grep -i 'example' text.txt

This will display all the lines in "text.txt" that contain the word "example" regardless of the case used.

The top command is a powerful utility in Linux that provides a real-time view of running processes and resource usage on a system. With its user-friendly display, it can show vital information such as CPU usage, memory usage, and the list of processes managed by the Linux Kernel. top also supports features like color customization, highlighting, and even elementary graphs for better visualization. It can be used to monitor system performance, troubleshoot performance issues, and identify resource-hungry processes. Overall, top is a valuable command for system monitoring and management in Linux environments.

In Linux, shadow passwords are given by storing the hashed passwords in a separate file /etc/shadow instead of storing them in the world-readable file /etc/passwd . Access to the shadow file is restricted to privileged users only.

The /etc/shadow file contains one entry per line for each user listed in the /etc/passwd file. Each line in /etc/shadow consists of nine fields, separated by colons ( : ), with the fields having the following meanings:

• Login name
• Password hash
• Date of the last password change
• Password minimum age
• Password maximum age
• Password warning period
• Password inactivity period
• Account expiration date
• A reserved field for future use

To create and manage shadow passwords, the passwd command can be used which will encrypt the password using a hashing algorithm such as MD5, SHA-256 or SHA-512 and store it in the /etc/shadow file .

The daemon used for scheduling commands in Linux is typically cron. Cron (short for chronograph) is a time-based job scheduler in Unix-like operating systems that is used to schedule commands or scripts to run automatically at specified intervals of time or dates. It runs in the background as a daemon process and triggers commands at the appropriate time according to the specified schedule.

Cron relies on a file called crontab, which is a table of commands with their specific execution times. The crontab file is edited using the crontab command and can be customized to include specific schedules for running commands or scripts.

Furthermore, there is another daemon for scheduling commands in Linux called at. The at daemon allows you to schedule a one-time task that will run at a specific scheduled time. The commands and tasks that are scheduled with the at daemon are stored in a queue, where each task will run at its designated time.

Both cron and at daemons are commonly used in Linux for scheduling commands and tasks based on specific timeframes.

Here is a sample shell script that checks if the file exists in the current directory and displays the appropriate message:

A Linux Administrator typically assigns the /bin/false shell to a POP3 mail-only account.

This shell is commonly used when you want to provide a user with mail access only and prevent them from having shell access to the system.

Please note that assigning the /bin/false shell ensures that the user cannot log in to the system using that account.

To extend an existing Linux volume group named VG0 up to 4 GB, you can follow these general steps:

• Check the available space in the Volume Group: Use the vgdisplay command to check the current available space in the VG0.
• Allocate additional physical volumes: If there are no available physical volumes, you may need to add new physical volumes to the volume group. You can use the **pvcreate **command to initialize the new physical volumes.
• Add the new physical volumes to the volume group: Once the physical volumes are created, you can use the vgextend command to add them to the existing VG0.
• Resize the logical volume(s): After extending the volume group, you can resize the logical volume(s) within it to allocate the desired additional space. Use the lvresize command to resize the logical volume(s) within VG0.
• Resize the underlying filesystem: Once the logical volume(s) are resized, you may need to resize the filesystem(s) within them to make use of the additional space. Depending on the filesystem type, you can use commands like resize2fs for ext-based filesystems or xfs_growfs for XFS filesystems.

Yes, there is a relation between the modprobe.conf file and network devices. The modprobe.conf file is used in Linux systems to specify various module options and dependencies. Network devices in Linux are often managed by kernel modules or drivers.

By configuring the modprobe.conf file, you can specify the behavior of the kernel modules related to network devices. This includes specifying options for network device drivers, enabling or disabling specific modules, and setting parameters for network interfaces.

Overall, the modprobe.conf file plays a role in managing and configuring network devices by controlling the behavior of kernel modules related to networking.

YUM stands for Yellowdog Updater Modifier and it is a package management utility commonly used in Linux operating systems. YUM enables users to easily manage software packages by providing a user-friendly interface for installing, updating, and removing packages. With YUM, you can search for specific packages, resolve dependencies, and handle package repositories. It is widely used in Red Hat-based distributions such as CentOS and Fedora.

YUM handles package dependencies by automatically resolving and installing the required packages when you request the installation or update of a particular software package. It checks the package database and retrieves the necessary dependencies from configured software repositories, ensuring that the software functions correctly.

Kudzu is a program that runs on the Linux operating system. Its main role is to detect and configure hardware changes that occur on a computer system. When new hardware is added or removed from a system, Kudzu detects these changes and takes appropriate action to configure the system to work with the new hardware. For example, if a new network card is added to a system, Kudzu will detect it and configure the system to use the new card. Similarly, when the hardware is unplugged or removed from the system, Kudzu will detect this and make any necessary configuration changes.

Yes, in modern Linux systems, hardware detection and configuration are typically handled by the udev subsystem along with tools like systemd-udev or eudev. These tools provide dynamic device management, automatic hardware detection, and robust support for hot-plugging devices, making them suitable replacements for Kudzu.

The /proc file system in Linux is a virtual file system that exists only in memory and allows access to kernel data structures through regular files. The files and directories in /proc are not actual physical files, rather they represent kernel data structures that can be accessed using standard I/O system calls like read, write, and open.

The /proc file system provides a way for users and programs to access and gather information about the current state of the system. This information includes system hardware, memory, running processes, system configuration parameters, and other kernel statistics that can be useful to system administrators and developers.

For example, the /proc/cpuinfo file provides information about the CPU installed on the system, while /proc/mounts lists all mounted file systems. The /proc file system also allows users to interact with kernel modules, monitor system performance, and modify kernel parameters at runtime.

Since /proc files are generated dynamically by the kernel, they can be used to monitor the system in real time and provide instant access to system information, as opposed to static configuration files that require a system restart to take effect.

To create an ext4 file system, you can use the mkfs.ext4 or mke4fs command to format a partition with the ext4 file system type. Here's an example command to format a new partition with the ext4 file system using the mkfs.ext4 command:

sudo mkfs.ext4 /dev/sdX1

Replace sdX1 with the appropriate device name and partition number. Please note that this will erase all the data on the partition.

Here are the steps to enable ACLs (Access Control Lists) for the /home partition in Linux:

Open the /etc/fstab file in a text editor:

sudo nano /etc/fstab

Find the line that corresponds to your /home partition. This should look similar to the following line:

UUID=<your_partition_UUID> /home ext4 defaults 0 2

Replace <your_partition_UUID> with the UUID of your /home partition, which you can find with the blkid command.

Add acl to the list of mount options for the /home partition. The resulting line should look like this:

UUID=<your_partition_UUID> /home ext4 defaults,acl 0 2

Save the changes and exit the text editor.

Remount the /home partition for the changes to take effect:

sudo mount -o remount /home

After completing these steps, you should have enabled ACLs for the /home partition in Linux and be able to set more specific permissions for files and directories within the /home directory.

To create a software RAID 1 in Linux for data redundancy by mirroring two disks, follow these steps:

First, ensure that both disks you want to use for the RAID are connected and recognized by your system. You can verify their names using the lsblk command.

Partition both disks. You can use a utility like fdisk or parted to create a partition on each disk. Make both partitions of the same size and type. Typically, the partition type for RAID is "Linux raid autodetect" (type code fd).

Create the RAID array using the mdadm (Multiple Device Admin) command. Use the following command to create the RAID 1 array, replacing /dev/sdX1 and /dev/sdY1 with the appropriate partition names for your disks:

After completing these steps, you should have successfully created a software RAID 1 in Linux with two disks for data redundancy. The RAID array will be automatically mounted on system startup and you can start using it for reliable and redundant storage.

To configure a Linux firewall and control incoming and outgoing traffic, you can use the built-in firewall management tools such as iptables or ufw. Here's a basic outline of the process:

• Identify the specific incoming and outgoing traffic that you want to allow or block.
• Use the appropriate commands to add rules to the firewall configuration.
• Specify the type of traffic (TCP, UDP, etc.), the source and destination IP addresses, and the port numbers.
• Verify the rules using the appropriate command.
• Save the firewall configuration to make it persistent across reboots.

• Open the terminal and login as root or a user with sudo privileges.
• Create a directory where you want to mount the NFS share, e.g., sudo mkdir /mnt/nfs_share.
• Edit the /etc/fstab file using a text editor, e.g., sudo nano /etc/fstab.
• Add the following line at the end of the file:
• < NFS-Server-IP >:< NFS-Share-Path > /mnt/nfs_share nfs defaults 0 0
• Save the file and exit the editor.
• Test the configuration by running sudo mount -a.
• If there are no errors, the NFS share should be mounted.
• Reboot your system, and the NFS share will be automatically mounted at startup.

• Open the terminal on your Linux system.
• Use the lsof command followed by the port number to find the processes using that port. For example, lsof -i :80 will list all processes using port 80.
• Note down the process IDs (PIDs) of the processes using the specific port.
• Use the kill command followed by the PID(s) to terminate the processes. For example, kill PID will kill the process with the specified PID.
• Confirm that the processes are terminated by re-running the lsof command.

• Identify bottlenecks: Start by examining the boot logs to identify any processes or services that are taking longer to start. Look for any errors or warnings that may be impacting the boot time.
• Disable unnecessary services: Disable any unnecessary services or daemons that are not required during the boot process. This can help reduce the overall boot time.
• Optimize init scripts: Review and optimize the init scripts to ensure they are executing efficiently. This may involve simplifying or rewriting certain scripts.
• Analyze hardware: Check the hardware configuration and ensure that the system has adequate resources to boot efficiently. Upgrading hardware, such as adding more RAM or replacing a slow hard drive, can significantly improve boot times.
• Monitor boot time: Use tools like systemd-analyze or bootchart to measure and monitor the boot time. This will help identify any improvements made and the impact of any changes.

To find the top 10 largest files and directories on your Linux system, you can use the 'du' (disk usage) command. First, navigate to the root directory of your system using the command line. Then, use the following command:

du -ah | sort -rh | head -n 10

This command will display the top 10 largest files and directories on your system, sorted in descending order with human-readable file sizes. The 'head -n 10' limits the output to only display the top 10 results. You can adjust the number to get more or fewer results. This command can help you identify large folders and files that are taking up valuable space on your system.

To set up a Linux system as a router using IP forwarding and iptables, there are several steps to follow. First, enable IP forwarding by editing the /etc/sysctl.conf file and uncommenting the line "net.ipv4.ip_forward=1". Then, configure the network interfaces with appropriate IP addresses. Next, use iptables to set up packet filtering and NAT rules to forward traffic between interfaces. The NAT rules allow private IP addresses to communicate with external networks by masquerading as the public IP address of the Linux system. Finally, save the iptables rules and configure them to be loaded upon boot. With these steps completed, the Linux system is now configured as a router.

• On the client server, generate a key pair (public and private) using the ssh-keygen command.
• Copy the public key to the remote server using the ssh-copy-id command.
• On the remote server, modify the permissions of the ~/.ssh directory to 700 and the authorized_keys file to 600.
• Disable password authentication on the remote server by modifying the sshd_config file and setting 'PasswordAuthentication' to 'no'.
• Restart the sshd service on the remote server.
• Now, whenever you connect to the remote server from the client server, SSH will use the public key to authenticate the connection, without the need for a password.

To automatically mount a USB drive on system startup, you can modify the /etc/fstab file. First, find the UUID of the USB drive by using the following command: sudo blkid. Next, create a mount point for the USB drive using the following command: sudo mkdir /media/usb. Finally, edit the /etc/fstab file and add the following line: UUID=[UUID of USB] /media/usb [file system type] [options] 0 2. Replace the [UUID of USB], [file system type], and [options] with the respective values from the output of the sudo blkid command. Save and close the file. Now, the USB drive will be automatically mounted on system startup.

To recursively find all files containing a specific string in their content, you can use a simple recursive function. Here's a basic approach:

• Start at the root directory.
• Iterate through each file and folder in the directory.
• If it's a directory, recursively call the function with that directory as the new root.
• If it's a file, read the file's content and check if the specific string is present.
• If the string is found, store the file path.
• Repeat steps 2-5 for all subdirectories and files.
• Return the list of file paths containing the specific string.

To set up a crontab to run a script in Linux every 15 minutes, you can add the following line to your crontab file:

*/15 * * * * /path/to/your_script

This will run your_script every 15 minutes. The */15 means "every 15 minutes," while the five asterisks denote the time and date fields for minute, hour, day of the month, month, and day of the week, respectively . Make sure to replace /path/to/your_script with the actual path to your script.

To edit your crontab file, run crontab -e in a terminal window. This will open the crontab file in your default text editor .