Bash sudo command not found windows

The «sudo: command not found» error in Git Bash typically occurs when the `sudo` command is not available on your system, as it is primarily a Linux utility and not natively included in Git Bash for Windows.

Here’s a simple code snippet to help check your user permissions:

whoami

What is Git Bash?

Git Bash is a command line interface designed for users who need to work with Git on Windows systems. It provides a familiar Unix-like environment, allowing developers to execute shell commands, manage files, and utilize version control in a way that resembles Linux and macOS systems. The convenience of using Git Bash lies in its simplicity and efficiency, enabling developers to focus on coding without extensive navigation through graphical interfaces.

Features of Git Bash

Git Bash offers several features that set it apart:

• Unix Command Support: It allows users to execute a wide array of Unix commands, making it easier for those transitioning from a Unix/Linux environment.
• Integration with Git Commands: Users can seamlessly run Git operations alongside traditional Unix commands.
• Customization Options: Git Bash can be tailored to the user’s preferences through configuration files, enabling a personalized workflow.

Картинка с сайта: bashcommands.com

bash Sudo Command Not Found: Quick Fixes and Tips

Understanding the Sudo Command

What is `sudo`?

The term `sudo` stands for «superuser do». It is a command used in Unix/Linux environments to allow authorized users to run specific commands as the root user or another user, as specified by the security policy. Essentially, `sudo` provides a way to manage command execution with elevated privileges without switching permanently to a root user account.

Why Use `sudo`?

The use of `sudo` is crucial in scenarios where a command requires higher permissions, such as:

• Installing Software: Many package managers (like `apt` or `yum`) require root access to install software or updates.
• Modifying System Files: Editing configurations for system services might require the elevated privileges provided by `sudo`.

For example, to install a package on a Debian-based system, you would use:

sudo apt-get install package-name

Картинка с сайта: bashcommands.com

bash Code Command Not Found: Quick Fixes and Tips

Why the «Command Not Found» Error Occurs

Explanation of the Error

When working in Git Bash, you may encounter the «command not found» error when trying to use `sudo`. This stems from the fact that Git Bash is not a full-fledged Unix/Linux environment. Unlike a native terminal in these systems, Git Bash does not include `sudo` because it is designed to work within Windows without administrative elevation.

Contextualizing the Error

Understanding the limitations of Git Bash is essential. While it supports many Unix commands, certain utilities like `sudo` are specific to Linux environments. This means that while you’re able to use standard commands, attempting to elevate privileges with `sudo` will result in an inaccessible command, as Git Bash relies on Windows security protocols.

Картинка с сайта: bashcommands.com

bash Curl Command Not Found: Troubleshooting Tips and Fixes

Possible Solutions to ‘Sudo Command Not Found’ Error

Alternative Commands

If you encounter the «git bash sudo command not found» error, consider using `runas`, the Windows equivalent to execute commands with administrative privileges:

runas /user:administrator "your-command-here"

This command prompts for the administrator password, allowing you to run the specified command with elevated rights.

Executing Commands with Elevated Privileges in Git Bash

For users who need a more Unix-like environment within Windows, installing Cygwin could be a viable alternative. Cygwin effectively emulates a Unix environment, including the ability to use `sudo`. To install Cygwin:

1. Download the setup executable from the official Cygwin website.
2. Follow the installation instructions, selecting the necessary packages for your needs.
3. Once installed, you can utilize `sudo` just like in a standard Unix terminal.

Installing a Linux-like Environment on Windows

Another option to overcome the limitations of Git Bash is to use the Windows Subsystem for Linux (WSL). WSL allows you to run a Linux distribution directly on Windows, including full support for `sudo`. Here’s how to install WSL:

1. Open PowerShell as an administrator.

2. Run the command:

   wsl --install
   

3. After the installation, restart your computer if prompted.

4. Choose a preferred Linux distribution during the setup.

This setup allows you to execute Linux commands, including `sudo`, without any issues, thereby enhancing your overall development experience.

Картинка с сайта: bashcommands.com

bash Nano Command Not Found: Quick Fixes and Tips

Practical Examples: Navigating Without Sudo

Running Commands as an Administrator

If you need to perform tasks that typically require `sudo`, you can execute them as an administrator using the aforementioned `runas` command. For example, if you want to create a protected file, you might try:

echo "Hello, World!" > /path/to/protected-file.txt

Instead, you would utilize PowerShell for elevation:

powershell -Command "Set-Content -Path 'C:\protected-file.txt' -Value 'Hello, World!'"

This method allows you to write to locations that require higher privileges without encountering the `sudo` issue.

Managing File Permissions

While Git Bash does not directly support `sudo`, you can still manage file permissions effectively using commands like `chmod`:

chmod 755 filename

This command is often used in Unix systems to modify file permissions, but in Git Bash, you may need to consider Windows-specific methods or Cygwin tools to achieve similar results.

Картинка с сайта: bashcommands.com

bash Node Command Not Found: Quick Fixes and Tips

Conclusion

Understanding the limitations of Git Bash concerning the `sudo` command is crucial for effective command line usage on Windows. While it supports many Unix-like commands, the absence of native support for `sudo` might pose challenges. However, by exploring alternative commands such as `runas`, utilizing tools like Cygwin, or leveraging the Windows Subsystem for Linux, users can efficiently manage administrative tasks and maximize their productivity. Embrace these alternatives to work around the «git bash sudo command not found» issue and continue improving your command line skills.

Картинка с сайта: bashcommands.com

Bash Command Not Found: Quick Fixes and Tips

Additional Resources

For more information, consider checking official documentation for Git, Bash, and the Windows Subsystem for Linux. Also, seek out community forums and user groups that delve deeper into Git Bash for shared knowledge and troubleshooting tips.

There are many scenarios when you get “sudo command not found error” and you keep looking for solutions on the internet to fix it. One of the common examples, when you have installed Debian with a minimal package and trying to run sudo. For me whenever I try to ssh into any of the remote servers and run sudo, I get this “bash: sudo commands not found error”. So I decided to write a post, which covers all the scenarios of this famous error.

Below mentioned errors will be covered in this post. so if you are getting any of the following errors, this post will definitely solve your error –

• sudo command not found mac
• sudo command not found ubuntu
• sudo command not found debian
• zsh sudo command not found
• sudo command not found windows
• sudo command not found centos
• bash: /usr/bin/sudo: No such file or directory

These are the common scenarios that result in this error –

• You have installed a linux distribution with minimal package like Debian
• Sudo is not installed
• Path is not setup for sudo command
• You are trying to ssh a remote server first time and sudo is not working

Before getting into the solutions, if you are a newbie let’s understand why sudo is used?

Why sudo is used in Linux before every command?

Sudo is one of the famous prefixes to any command you run in the Linux world. It allows running any Linux command with elevated privileges to run administrative tasks. Also, the operations which are only permitted by a root user can be done using a normal user with sudo rights. The “sudoers” file controls, who can use the sudo command to gain elevated access and location is /etc/sudoers in all Linux distributions.

How to fix sudo command not found error in Debian/Ubuntu like Distros

As we discussed already, there may be many reasons to encounter this error. As you will see in the image, running the “sudo ifconfig -a” command results in “bash: /usr/bin/sudo: No such file or directory error“. I am running this command in Ubuntu 21.04 installed as VM.

Картинка с сайта: cloudlinuxtech.com

Let’s deep dive and find the fixes for different scenarios –

Solution-1 Check and install sudo package

This is very uncommon when sudo is not installed by default with Linux installation. Still, you may get this situation when you have installed the Debian Linux with the minimal package. Follow these steps to fix it –

Step1.1 List installed packages in Ubuntu and look for the “sudo” package

$ apt list --installed | grep -i sudo

Картинка с сайта: cloudlinuxtech.com

If you can find package name sudo with “installed” status as shown in the image. Then you can directly move to solution-2 to fix the “sudo: command not found error“.

If you don’t have the sudo package installed, run the following command to install it in Ubuntu or Debian based distros. You would need root access to achieve this.

Step1.2 Switch to root user

$ su root

Enter “root” password, when prompted.

If you don’t have a root password, then follow this link to reset your root password.

Step1.3 Run apt command to install sudo package in Ubuntu/Debian

# apt install sudo

Refer to the following image for reference.

Картинка с сайта: cloudlinuxtech.com

Step1.4 Give sudo rights to your own user by adding it to the sudo group

# usermod -aG sudo yourusername

For example, I will add my user “dev” to sudo group –

# usermode -aG sudo dev

Картинка с сайта: cloudlinuxtech.com

Step1.5 Verify your user is added to the sudo group

Open /etc/passwd file and check whether your user is added to the sudo group or not.

# cat /etc/group | grep -i username

I will check for my user “dev” in this example.

 # more /etc/group | grep -i username 

Картинка с сайта: cloudlinuxtech.com

Step1.6 Make sure your sudoers file have sudo group added

• Run visudo command to modify sudoers file and add the following line into it (if it is missing):

# Allow members of group sudo to execute any command
%sudo   ALL=(ALL:ALL) ALL

Картинка с сайта: cloudlinuxtech.com

Press Ctrl + X and press “Y” to save the file and exit from the nano editor.

Exit from the root shell and check the sudo command functionality.

• Run sudo -h command. Now you will not get any “sudo command not found error” as it’s fixed now.

Картинка с сайта: cloudlinuxtech.com

Solution2 – Setup path variable to fix sudo command not found errors

If you have a sudo package installed as explained in Step 1.1 and still you are getting sudo command not found error. It means you don’t have “/usr/bin/” setup in the PATH variable or your /etc/environment file got messed up.

To add sudo in your Path variable, add /usr/bin/ directory by following the method.

Step2.1 Switch to root user

$ su root

Enter root user password, when asked.

Step2.2 Run /usr/bin/sudo command to check whether it’s working or not

# /usr/bin/sudo -h

Step2.3 Edit /etc/environment file and add “/usr/bin" directory in PATH

# vi /etc/environment

Картинка с сайта: cloudlinuxtech.com

Alternatively, you can also run export command to set up the path variable

export PATH=$PATH:/usr/bin

In case you are getting visudo and usermod command not found errors also. Make sure you add /usr/sbin in the PATH variable as shown in the last step.

Fix “sudo command not found error” in Fedora/AlmaLinux/Rocky Linux Distros

This section covers sudo error for all the Linux distros based on RedHat like Fedora, AlmaLinux, CentOS and Rocky Linux. I have Rocky Linux Installed as a virtual machine. The procedure is the same as explained earlier, Look for the package, install it and set the path variable, if required. But the commands will differ now.

Solution3- Install sudo and add user to “Wheel” group to fix sudo errors

You have the option to set up sudo during installation in RedHat based Linux distros. But if you forgot to do that, You must have access to the root user to set up sudo for your user.

Step3.1 – Login with root user and check for sudo package installation

Follow this link to reset your root password, in case you forgot or don’t have it.

Once you are done with login as root, open Terminal and type

# yum list installed | grep -i sudo

If you get the sudo package installed already skip to the next step3.3.

Step3.2 Install sudo package

You can use the “yum” or “dnf” command to install any package from the repository.

Update all old packages and refresh the repository.

# dnf update 

Then install the sudo package using the dnf or yum command.

# yum install sudo

or
 
# dnf install sudo

Картинка с сайта: cloudlinuxtech.com

Step3.3 Add user to the wheel group

The wheel group is already set to provide sudo access to run all commands. So is the quickest way is to add your user to this group. Switch to the root user first using su command

su -

Now run usermod command to add your user in the wheel group.

# usermod -a -G wheel "username"

For example, I will add my user “dev” as an example

 # usermod -a -G wheel "dev" 

Картинка с сайта: cloudlinuxtech.com

Step4.4 Check with the id command

Next, run the id command to see whether your user is part of the wheel group or not.

# id "username" 

Example: My user dev is part of 10(wheel) the group.

# id dev

Картинка с сайта: cloudlinuxtech.com

Congrats! you must have fixed your “sudo command not found error ” now and you can run all your privileged commands using sudo.

Frequently asked questions on sudo

Ending Note

I have covered all the possible solutions to fix the sudo command not found error and I hope this tutorial is helpful to you. In case, none of the solutions works for you and your system has broken severly, Either re-install your system or let me know the issue via your comments.

I will try to help you to the best of my knowledge.

Keep Learning!!

Ever been locked out of important system tasks due to the ‘sudo command not found’ error in bash? You’re not alone. Many developers find themselves puzzled when encountering this common bash error, but we’re here to help.

Think of the sudo command as a master key – a key that unlocks the ability to perform critical system tasks. However, when this key goes missing, it can leave you stranded, unable to execute important commands.

In this guide, we’ll help you understand and resolve the ‘sudo command not found’ error in bash, from the basics to more advanced techniques. We’ll cover everything from understanding the sudo command, the role of the PATH variable, to troubleshooting and fixing the error.

So, let’s dive in and start unlocking the mystery behind the ‘sudo command not found’ error!

TL;DR: How Do I Fix ‘sudo command not found’ in Bash?

To fix the 'sudo command not found' error, you need to ensure that the sudo package is installed correctly. This can be achieved with the command which sudo || apt-get install sudo. This bash error usually means that either the sudo package is not installed, or your PATH variable does not include the directory where sudo is located.

Here’s a quick example on a Debian-based system:

which sudo || apt-get install sudo

# Output:
# /usr/bin/sudo (if sudo is installed)

In this example, the which command checks if sudo is installed and returns its location if it is. If sudo is not found, the command after the || operator runs, which installs sudo using apt-get install sudo.

This is a quick fix, but understanding why this error occurs and how to prevent it requires a deeper understanding of bash and the sudo command. Continue reading for a detailed guide on troubleshooting and understanding this issue.

Understanding the Sudo Command and Its Role

The sudo command is a crucial tool in a Linux system. It stands for ‘superuser do,’ allowing a permitted user to execute a command as the superuser or another user, as specified in the sudoers file. This command is vital for performing tasks that require administrative or root permissions.

Let’s illustrate with a simple example. If you want to update the package list on your system, you’d use the apt-get update command. But without the sudo prefix, you might encounter a ‘Permission denied’ error. Here’s how you’d use sudo to avoid this.

sudo apt-get update

# Output:
# Hit:1 http://archive.ubuntu.com/ubuntu bionic InRelease
# Get:2 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]
# ...

In this example, sudo allows the apt-get update command to run with root permissions, successfully updating the package list.

Bash Command Interpretation and the PATH Variable

When you type a command in bash, the shell needs to know where to find that command’s corresponding program. It does this using the PATH variable. The PATH variable is a list of directories that bash searches whenever you enter a command.

If the directory containing sudo is not in your PATH, you’ll encounter the ‘sudo command not found’ error. You can view your current PATH with the echo command:

echo $PATH

# Output:
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

In this output, each directory is separated by a colon. Bash will look for commands in these directories in the order they appear.

Modifying the PATH Variable

If you find that the directory containing sudo is not in your PATH, you can add it using the export command. Suppose sudo is in the /usr/local/bin directory. You’d add it to your PATH like so:

export PATH=$PATH:/usr/local/bin

This command appends /usr/local/bin to your existing PATH. After running this, bash should be able to locate sudo and run it successfully.

Troubleshooting ‘sudo command not found’ Error

The ‘sudo command not found’ error can stem from several sources. Let’s go through the common causes one by one and provide solutions for each.

Sudo Package Not Installed

The most straightforward cause is that the sudo package itself is not installed on your system. You can check this by trying to display the location of sudo using the whereis command:

whereis sudo

# Output:
# sudo: /usr/bin/sudo /usr/lib/sudo /usr/share/man/man8/sudo.8.gz

In this example, whereis returns the locations associated with sudo. If sudo is not installed, this command will return sudo: without any paths following it.

If you find that sudo is not installed, you can install it using the package manager of your Linux distribution. For Debian-based distributions like Ubuntu, you would use apt-get:

su -c 'apt-get install sudo'

# Output:
# Reading package lists... Done
# Building dependency tree
# Reading state information... Done
# ...

In this example, su -c allows you to run a command as the superuser. The command we’re running is apt-get install sudo, which installs the sudo package.

PATH Does Not Include Sudo’s Directory

Another common cause is that your PATH variable does not include the directory where sudo is located. You can check your PATH with the echo command:

echo $PATH

# Output:
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

If the directory containing sudo (usually /usr/bin or /usr/sbin) is not in your PATH, you can add it using the export command:

export PATH=$PATH:/usr/bin

This command appends /usr/bin to your existing PATH. After running this, bash should be able to locate sudo and run it successfully.

User Does Not Have Sudo Privileges

The final common cause we’ll discuss is the possibility that your user does not have sudo privileges. You can check this by looking at the sudoers file, which defines which users have sudo privileges. Open the sudoers file with the visudo command:

su -c 'visudo'

# Output:
# # /etc/sudoers
# # ...
# root    ALL=(ALL:ALL) ALL
# %sudo   ALL=(ALL:ALL) ALL
# ...

In this example, the root user and all users in the sudo group have sudo privileges. If your user is not listed here, you can add it using the same visudo command.

Diving Deeper: Advanced Sudo and Bash Concepts

Now that we’ve covered the basics and common troubleshooting steps, let’s delve into more advanced topics related to sudo and bash. This will not only help you better understand the ‘sudo command not found’ error but also equip you with knowledge to handle similar issues in the future.

The Sudoers File: Gatekeeper of Sudo Privileges

The sudoers file is a critical configuration file that controls who can use the sudo command and how. It’s located at /etc/sudoers and can be edited using the visudo command.

sudo visudo

# Output:
# # /etc/sudoers
# # ...
# root    ALL=(ALL:ALL) ALL
# %sudo   ALL=(ALL:ALL) ALL
# ...

In this example, the root user and all users in the sudo group have sudo privileges. You can add or remove users or groups as needed, following the same format.

The secure_path Directive: A Safety Net for Sudo

The sudoers file can also contain a secure_path directive. This directive sets a hard-coded PATH for all commands run with sudo, regardless of the user’s current PATH. This is a security feature to prevent malicious programs from hijacking your commands.

grep secure_path /etc/sudoers

# Output:
# Defaults    secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

In this example, the secure_path directive sets a PATH that includes common command directories. If your sudo command is in one of these directories, it should always be found when using sudo, even if it’s not in your user’s PATH.

Absolute vs Relative Paths: Navigating Your Filesystem

Finally, understanding the difference between absolute and relative paths can help you troubleshoot PATH-related issues. An absolute path starts from the root directory (e.g., /usr/bin/sudo), while a relative path starts from the current directory (e.g., ./sudo).

cd /usr/bin
./sudo -V

# Output:
# Sudo version 1.8.31
# ...

In this example, we navigate to /usr/bin with cd and then run sudo with a relative path (./sudo). This works even if /usr/bin is not in your PATH, as we’re directly specifying sudo’s location.

Bash Shell and Command Execution

The Bash shell is a command interpreter for Linux systems. When you type a command in Bash, it interprets the command and executes the associated program. This process involves searching for the program in the directories listed in your PATH variable.

Let’s consider an example where we execute the ls command:

ls

# Output:
# Documents  Downloads  Pictures  ...

In this example, Bash finds the ls program in one of the directories listed in the PATH variable and executes it, listing the contents of the current directory.

The Role of the PATH Variable

The PATH variable is a critical component in how Bash executes commands. It is a list of directories that Bash searches for the executable file associated with a command. When the system is unable to find the command in the directories listed in the PATH variable, it returns a ‘command not found’ error.

Here’s an example of viewing the PATH variable:

echo $PATH

# Output:
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

In this output, each directory is separated by a colon. Bash will look for commands in these directories in the order they appear.

The Principle of Least Privilege and Sudo

The principle of least privilege is a computer security concept in which a user is given the minimum levels of access necessary to complete his/her job functions. The sudo command in Linux is an embodiment of this principle.

The sudo command allows a permitted user to execute a command as the superuser or another user, as specified in the sudoers file. This allows users to perform tasks that require higher privileges without having to log in as the root user.

For example, here’s how you’d use sudo to edit the sudoers file:

sudo visudo

# Output:
# # /etc/sudoers
# # ...
# root    ALL=(ALL:ALL) ALL
# %sudo   ALL=(ALL:ALL) ALL
# ...

In this example, sudo visudo opens the sudoers file in a text editor with root permissions, allowing you to make changes to the file.

Expanding Your Bash Knowledge: Beyond ‘sudo command not found’

Understanding the ‘sudo command not found’ error can equip you with the skills to troubleshoot similar errors in bash. The principles and techniques you’ve learned here can be applied to other ‘command not found’ errors, helping you become a more effective system administrator.

Exploring File Permissions

File permissions are a fundamental concept in Linux. They dictate who can read, write, or execute a file. Understanding file permissions can help you troubleshoot a variety of issues, including ‘command not found’ errors. You can view the permissions of a file using the ls -l command:

ls -l /usr/bin/sudo

# Output:
# -rwsr-xr-x 1 root root 136808 Feb  2  2020 /usr/bin/sudo

In this example, the permissions of the sudo command are displayed. The rwsr-xr-x string shows that the owner (root) can read, write, and execute sudo, while other users can only read and execute it.

Mastering User and Group Management

User and group management is another important skill for system administrators. It involves creating, deleting, and modifying users and groups, as well as managing their permissions. The useradd, userdel, groupadd, and groupdel commands are some of the tools you’ll use for user and group management.

Diving into Common Bash Commands

Finally, familiarizing yourself with common bash commands can make you more efficient at the command line. Commands like cd, ls, pwd, and rm are used daily by system administrators. Knowing these commands and their options can make you more productive and help you troubleshoot issues faster.

Further Resources for Bash Proficiency

To continue your journey in mastering Bash, consider exploring these resources:

• GNU Bash Manual: The official manual for Bash, covering all its features and capabilities.
• Linux Command Library: An extensive library of Linux commands, complete with descriptions and examples.
• Advanced Bash-Scripting Guide: A comprehensive guide to scripting in Bash, suitable for all levels of experience.

Wrapping Up: Solving the ‘sudo command not found’ Bash Error

In this comprehensive guide, we’ve delved deep into understanding and resolving the ‘sudo command not found’ error in bash. We’ve explored the role of the sudo command and the PATH variable in a Linux system, and how their misconfiguration can lead to this common yet puzzling error.

We began with the basics, explaining the role of the sudo command and how the bash shell locates commands using the PATH variable. We then delved into troubleshooting, providing solutions for common causes of the error, such as the sudo package not being installed, the PATH variable not including the directory of sudo, and the user not having sudo privileges.

Venturing into more advanced territory, we discussed the sudoers file, the secure_path directive, and the difference between absolute and relative paths. These concepts not only help in understanding the ‘sudo command not found’ error but also equip you with knowledge to handle similar issues in the future.

Whether you’re a beginner just starting out with bash, or an experienced system administrator looking for a refresher, we hope this guide has helped you understand and resolve the ‘sudo command not found’ error. With a clear grasp of these concepts, you’re now better prepared to tackle system administration tasks in bash. Happy coding!

Advertisement

Encountering the “sudo: command not found” error can be frustrating, especially when you’re trying to perform administrative tasks on a Linux server. This error indicates that the system is unable to locate the sudo command, which is essential for executing commands with superuser privileges. Fortunately, there are several troubleshooting steps and solutions to resolve this issue and regain access to sudo functionality. The error looks like this:

Also Read: What is Superuser (Root Account) in Unix & Linux

sudo (su “do”) is a command on Unix and Unix-like operating systems such as Linux or macOS that is used to start processes with the privileges of another user (e.g. the superuser root). In contrast to su, which does not belong to sudo, it is possible to configure which commands may be executed. sudo itself a program, with its own official website which troubleshoots various complex errors:

Usually, the sudo package by default is installed in most Linux distributions, but some Debian systems may not have it pre-installed. Usually, the sudo: command not found error is not a serious issue.

Understanding sudo: command not found Error

Before delving into the solutions, it’s essential to understand why the “sudo: command not found” error occurs. The sudo command is typically located in the /usr/bin directory, which is included in the system’s PATH environment variable. When you enter a command prefixed with sudo, the system searches the directories listed in the PATH variable to find the sudo executable. If it fails to locate sudo in any of these directories, it returns the “command not found” error.

To fix this error, logging into the system as the root user is required. You can also switch to the root user, which uncannily involves the sudo command:

Of course, if my username is abhishek and I am not in the sudoers group, then I may face this error. So, I need to add my username to the group.

Make sure your sudoers file has a sudo group added. Run visudo to modify the sudoers file and add the following line into it (if it is missing):

If the sudo program is not at all installed, naturally it will throw the error. Ensure that sudo is installed on your system. You can do this by running the following command:

If sudo is installed, the command will return the path to the sudo executable (e.g., /usr/bin/sudo). If sudo is not installed, you’ll need to install it using your package manager (e.g., apt-get, yum), for example:

Next if still not fixed, we should check the PATH. Verify that the PATH environment variable is correctly configured and includes the directory where sudo is located (/usr/bin). You can check the PATH variable by running the following command:

The above situations are common clauses of getting the error. There are other clauses too. The sudo command should have the correct permissions (typically executable by root) to be executed. You can check the permissions using the ls command:

Картинка с сайта: thecustomizewindows.com

If the permissions are incorrect, you can use the chmod command to adjust them:

If sudo is installed but still not found, try reinstalling it using your package manager. This can help fix any corrupted installation or missing files:

If the PATH variable has been modified or corrupted, you can restore it to its default value. You can find the default PATH variable for your system in the /etc/environment file and update it accordingly. You added it to the root’s ~/.bashrc:

and reload the file with reload command.

So, the “sudo: command not found” error can occur due to various reasons, including misconfigured PATH variable, missing sudo installation, or incorrect file permissions. Usually, it is a small issue. Remember to exercise caution when making changes to system files and configurations, especially when dealing with administrative privileges.

This repository was archived by the owner on Sep 26, 2021. It is now read-only.

$ echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
$ echo never | sudo tee /sys/kernel/mm/transparent_hugepage/defrag

$ echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
bash: sudo: command not found