How to Use SSH Keys for Authentication
Linux
Servers
SSH
30.01.2025
Reading time: 10 min
Share
Many cloud applications are built on the popular SSH protocol—it is widely used for managing network infrastructure, transferring files, and executing remote commands.
SSH stands for Secure Socket Shell, meaning it provides a shell (command-line interface) around the connection between multiple remote hosts, ensuring that the connection is secure (encrypted and authenticated).
SSH connections are available on all popular operating systems, including Linux, Ubuntu, Windows, and Debian. The protocol establishes an encrypted communication channel within an unprotected network by using a pair of public and private keys.
Keys: The Foundation of SSH
SSH operates on a client-server model. This means the user has an SSH client (a terminal in Linux or a graphical application in Windows), while the server side runs a daemon, which accepts incoming connections from clients.
In practice, an SSH channel enables remote terminal management of a server. In other words, after a successful connection, everything entered in the local console is executed directly on the remote server.
The SSH protocol uses a pair of keys for encrypting and decrypting information: public key and private key.
These keys are mathematically linked. The public key is shared openly, resides on the server, and is used to encrypt data. The private key is confidential, resides on the client, and is used to decrypt data.
Of course, keys are not generated manually but with special tools—keygens. These utilities generate new keys using encryption algorithms fundamental to SSH technology.
More About How SSH Works
Exchange of Public Keys
SSH relies on symmetric encryption, meaning two hosts wishing to communicate securely generate a unique session key derived from the public and private data of each host.
For example, host A generates a public and private key pair. The public key is sent to host B. Host B does the same, sending its public key to host A.
Using the Diffie-Hellman algorithm, host A can create a key by combining its private key with the public key of host B. Likewise, host B can create an identical key by combining its private key with the public key of host A.
This results in both hosts independently generating the same symmetric encryption key, which is then used for secure communication. Hence, the term symmetric encryption.
Message Verification
To verify messages, hosts use a hash function that outputs a fixed-length string based on the following data:
- The symmetric encryption key
- The packet number
- The encrypted message text
The result of hashing these elements is called an HMAC (Hash-based Message Authentication Code). The client generates an HMAC and sends it to the server. The server then creates its own HMAC using the same data and compares it to the client's HMAC. If they match, the verification is successful, ensuring that the message is authentic and hasn't been tampered with.
Host Authentication
Establishing a secure connection is only part of the process. The next step is authenticating the user connecting to the remote host, as the user may not have permission to execute commands.
There are several authentication methods:
- Password Authentication: The user sends an encrypted password to the server. If the password is correct, the server allows the user to execute commands.
- Certificate-Based Authentication: The user initially provides the server with a password and the public part of a certificate. Once authenticated, the session continues without requiring repeated password entries for subsequent interactions.
These methods ensure that only authorized users can access the remote system while maintaining secure communication.
Encryption Algorithms
A key factor in the robustness of SSH is that decrypting the symmetric key is only possible with the private key, not the public key, even though the symmetric key is derived from both. Achieving this property requires specific encryption algorithms.
There are three primary classes of such algorithms: RSA, DSA, and algorithms based on elliptic curves, each with distinct characteristics:
- RSA: Developed in 1978, RSA is based on integer factorization. Since factoring large semiprime numbers (products of two large primes) is computationally difficult, the security of RSA depends on the size of the chosen factors. The key length ranges from 1024 to 16384 bits.
- DSA: DSA (Digital Signature Algorithm) is based on discrete logarithms and modular exponentiation. While similar to RSA, it uses a different mathematical approach to link public and private keys. DSA key length is limited to 1024 bits.
- ECDSA and EdDSA: These algorithms are based on elliptic curves, unlike DSA, which uses modular exponentiation. They assume that no efficient solution exists for the discrete logarithm problem on elliptic curves. Although the keys are shorter, they provide the same level of security.
Key Generation
Each operating system has its own utilities for quickly generating SSH keys.
In Unix-like systems, the command to generate a key pair is:
ssh-keygen -t rsaHere, the type of encryption algorithm is specified using the -t flag. Other supported types include:
dsaecdsaed25519
You can also specify the key length with the -b flag. However, be cautious, as the security of the connection depends on the key length:
ssh-keygen -b 2048 -t rsaAfter entering the command, the terminal will prompt you to specify a file path and name for storing the generated keys. You can accept the default path by pressing Enter, which will create standard file names: id_rsa (private key) and id_rsa.pub (public key).
Thus, the public key will be stored in a file with a .pub extension, while the private key will be stored in a file without an extension.
Next, the command will prompt you to enter a passphrase. While not mandatory (it is unrelated to the SSH protocol itself), using a passphrase is recommended to prevent unauthorized use of the key by a third-party user on the local Linux system. Note that if a passphrase is used, you must enter it each time you establish the connection.
To change the passphrase later, you can use:
ssh-keygen -pOr, you can specify all parameters at once with a single command:
ssh-keygen -p old_password -N new_password -f path_to_filesFor Windows, there are two main approaches:
-
Using ssh-keygen from OpenSSH: The OpenSSH client provides the same
ssh-keygencommand as Linux, following the same steps. -
Using PuTTY: PuTTY is a graphical application that allows users to generate public and private keys with the press of a button.
Installing the Client and Server Components
The primary tool for an SSH connection on Linux platforms (both client and server) is OpenSSH. While it is typically pre-installed on most operating systems, there may be situations (such as with Ubuntu) where manual installation is necessary.
The general command for installing SSH, followed by entering the superuser password, is:
sudo apt-get install sshHowever, in some operating systems, SSH may be divided into separate components for the client and server.
For the Client
To check whether the SSH client is installed on your local machine, simply run the following command in the terminal:
sshIf SSH is supported, the terminal will display a description of the command. If nothing appears, you’ll need to install the client manually:
sudo apt-get install openssh-clientYou will be prompted to enter the superuser password during installation. Once completed, SSH connectivity will be available.
For the Server
Similarly, the server-side part of the OpenSSH toolkit is required on the remote host.
To check if the SSH server is available on your remote host, try connecting locally via SSH:
ssh localhostIf the SSH daemon is running, you will see a message indicating a successful connection. If not, you’ll need to install the SSH server:
sudo apt-get install openssh-serverAs with the client, the terminal will prompt you to enter the superuser password. After installation, you can check whether SSH is active by running:
sudo service ssh statusOnce connected, you can modify SSH settings as needed by editing the configuration file:
./ssh/sshd_configFor example, you might want to change the default port to a custom one. Don’t forget that after making changes to the configuration, you must manually restart the SSH service to apply the updates:
sudo service ssh restartCopying an SSH Key to the Server
On Hostman, you can easily add SSH keys to your servers using the control panel.
Using a Special Copy Command
After generating a public SSH key, it can be used as an authorized key on a server. This allows quick connections without the need to repeatedly enter a password.
The most common way to copy the key is by using the ssh-copy-id command:
ssh-copy-id -i ~/.ssh/id_rsa.pub name@server_addressThis command assumes you used the default paths and filenames during key generation. If not, simply replace ~/.ssh/id_rsa.pub with your custom path and filename.
-
Replace
namewith the username on the remote server. -
Replace
server_addresswith the host address. If the usernames on both the client and server are the same, you can shorten the command:
ssh-copy-id -i ~/.ssh/id_rsa.pub server_addressIf you set a passphrase during the SSH key creation, the terminal will prompt you to enter it. Otherwise, the key will be copied immediately.
In some cases, the server may be configured to use a non-standard port (the default is 22). If that’s the case, specify the port using the -p flag:
ssh-copy-id -i ~/.ssh/id_rsa.pub -p 8129 name@server_addressSemi-Manual Copying
There are operating systems where the ssh-copy-id command may not be supported, even though SSH connections to the server are possible. In such cases, the copying process can be done manually using a series of commands:
ssh name@server_address 'mkdir -pm 700 ~/.ssh; echo ' $(cat ~/.ssh/id_rsa.pub) ' >> ~/.ssh/authorized_keys; chmod 600 ~/.ssh/authorized_keys'This sequence of commands does the following:
-
Creates a special
.sshdirectory on the server (if it doesn’t already exist) with the correct permissions (700) for reading and writing. -
Creates or appends to the
authorized_keysfile, which stores the public keys of all authorized users. The public key from the local file (id_rsa.pub) will be added to it. -
Sets appropriate permissions (600) on the
authorized_keysfile to ensure it can only be read and written by the owner.
If the authorized_keys file already exists, it will simply be appended with the new key.
Once this is done, future connections to the server can be made using the same SSH command, but now the authentication will use the public key added to authorized_keys:
ssh name@server_addressManual Copying
Some hosting platforms offer server management through alternative interfaces, such as a web-based control panel. In these cases, there is usually an option to manually add a public key to the server. The web interface might even simulate a terminal for interacting with the server.
Regardless of the method, the remote host must contain a file named ~/.ssh/authorized_keys, which lists all authorized public keys.
Simply copy the client’s public key (found in ~/.ssh/id_rsa.pub by default) into this file.
If the key pair was generated using a graphical application (typically PuTTY on Windows), you should copy the public key directly from the application and add it to the existing content in authorized_keys.
Connecting to a Server
To connect to a remote server on a Linux operating system, enter the following command in the terminal:
ssh name@server_addressAlternatively, if the local username is identical to the remote username, you can shorten the command to:
ssh server_addressThe system will then prompt you to enter the password. Type it and press Enter. Note that the terminal will not display the password as you type it.
Just like with the ssh-copy-id command, you can explicitly specify the port when connecting to a remote server:
ssh client@server_address -p 8129Once connected, you will have control over the remote machine via the terminal; any command you enter will be executed on the server side.
Conclusion
Today, SSH is one of the most widely used protocols in development and system administration. Therefore, having a basic understanding of its operation is crucial.
This article aimed to provide an overview of SSH connections, briefly explain the encryption algorithms (RSA, DSA, ECDSA, and EdDSA), and demonstrate how public and private key pairs can be used to establish secure connections with a personal server, ensuring that exchanged messages remain inaccessible to third parties.
We covered the primary commands for UNIX-like operating systems that allow users to generate key pairs and grant clients SSH access by copying the public key to the server, enabling secure connections.
Linux
Servers
SSH
30.01.2025
Reading time: 10 min
Share
Similar
Linux
How to Find a File in Linux
In Unix-like operating systems, a file is more than just a named space on a disk. It is a universal interface for accessing information. A Linux user should know how to quickly find the necessary files by name and other criteria.
The locate Command
The first file search command in Linux that we will look at is called locate. It performs a fast search by name in a special database and outputs all names matching the specified substring.
Suppose we want to find all programs that begin with zip. Since we are looking specifically for programs, it is logical to assume that the directory name ends with bin. Taking this into account, let’s try to find the necessary files:
locate bin/zip
Output:
locate performed a search in the pathname database and displayed all names containing the substring bin/zip.
For more complex search criteria, locate can be combined with other programs, for example, grep:
locate bin | grep zip
Output:
Sometimes, in Linux, searching for a file name with locate works incorrectly (it may output names of deleted files or fail to include newly created ones). In such a case, you need to update the database of indexes:
sudo updatedb
locate supports wildcards and regular expressions. If the string contains metacharacters, you pass a pattern instead of a substring as an argument, and the command matches it against the full pathname.
Let’s say we need to find all names with the suffix .png in the Pictures directory:
locate '*Pictures/*.png'
Output:
To search using a regular expression, the -r option is used (POSIX BRE standard):
locate -r 'bin/\(bz\|gz\|zip\)'
The find Command
find is the main tool for searching files in Linux through the terminal. Unlike locate, find allows you to search files by many parameters, such as size, creation date, permissions, etc.
In the simplest use case, we pass the directory name as an argument and find searches for files in this directory and all of its subdirectories. If you don’t specify any options, the command outputs a list of all files.
For example, to get all names in the home directory, you can use:
find ~
The output will be very large because find will print all names in the directory and its subdirectories.
To make the search more specific, use options to set criteria.
Search Criteria
Suppose we want to output only directories. For this, we will use the -type option:
find ~/playground/ -type d
Output:
This command displayed all subdirectories in the ~/playground directory. Supported types are:
b — block device
c — character device
d — directory
f — regular file
l — symbolic link
We can also search by size and name. For example, let’s try to find regular files matching the pattern .png and larger than one kilobyte:
find ~ -type f -name "*.png" -size +1k
Output:
The -name option specifies the name. In this example, we use a wildcard pattern, so it is enclosed in quotes. The -size parameter restricts the search by size. A + sign before the number means we are looking for files larger than the given size, a - sign means smaller. If no sign is present, find will display only files exactly matching the size.
Symbols for size units:
b — 512-byte blocks (default if no unit is specified)
c — bytes
w — 2-byte words
k — kilobytes
M — megabytes
G — gigabytes
find supports a huge number of checks that allow searching by various criteria. You can check them all in the documentation.
Operators
Operators help describe logical relationships between checks more precisely.
Suppose we need to detect insecure permissions. To do this, we want to output all files with permissions not equal to 0600 and all directories with permissions not equal to 0700. find provides special logical operators to combine such checks:
find ~ \( -type f -not -perm 0600 \) -or \( -type d -not -perm 0700 \)
Supported logical operators:
-and / -a — logical AND. If no operators are specified between checks, AND is assumed by default.
-or / -o — logical OR.
-not / ! — logical NOT.
( ) — allows grouping checks and operators to create complex expressions. Must be escaped.
Predefined Actions
We can combine file search with performing actions on the found files. There are predefined and user-defined actions. For the former, find provides the following options:
-delete — delete found files
-ls — equivalent to ls -dils
-print — output the full file name (default action)
-quit — stop after the first match
Suppose we need to delete all files with the .bak suffix. Of course, we could immediately use find with the -delete option, but for safety it’s better to first output the list of files to be deleted, and then remove them:
find ~ -type f -name '*.bak' -print
Output:
After verification, delete them:
find ~ -type f -name '*.bak' -delete
User-defined Actions
With user-defined actions, we can combine the search with using various Linux utilities:
-exec command '{}' ';'
Here, command is the command name, {} is the symbolic representation of the current pathname, and ; is the command separator. For example, we can apply the ls -l command to each found file:
find ~ -type f -name 'foo*' -exec ls -l '{}' ';'
Output:
Sometimes commands can take multiple arguments at once, for example, rm. To avoid applying the command separately to each found name, put a + at the end of -exec instead of a separator:
find ~ -type f -name 'foo*' -exec ls -l '{}' +
Output:
A similar task can be done using the xargs utility. It takes a list of arguments as input and forms commands based on them. For example, here’s a well-known command for outputting files that contain “uncomfortable” characters in their names (spaces, line breaks, etc.):
find ~ -iname '*.jpg' -print0 | xargs --null ls -l
The -print0 argument forces found names to be separated by the null character (the only character forbidden in file names). The --null option in xargs indicates that the input is a list of arguments separated by the null character.
Conclusion
In Linux, searching for a file by name is done using the locate and find commands. Of course, you can also use file managers with a familiar graphical interface for these purposes. However, the utilities we have considered help make the search process more flexible and efficient.
22 August 2025 · 5 min to read
Java
Switching between Java Versions on Ubuntu
Managing multiple Java versions on Ubuntu is essential for developers working on diverse projects. Different applications often require different versions of the Java Development Kit (JDK) or Java Runtime Environment (JRE), making it crucial to switch between these versions efficiently. Ubuntu provides powerful tools to handle this, and one of the most effective methods is using the update-java-alternatives command.
Switching Between Java Versions
In this article, the process of switching between Java versions using updata-java-alternatives will be shown. This specialized tool simplifies the management of Java environments by updating all associated commands (such as java, javac, javaws, etc.) in one go.
Overview of Java version management
A crucial component of development is Java version control, especially when working on many projects with different Java Runtime Environment (JRE) or Java Development Kit (JDK) needs. In order to prevent compatibility problems and ensure efficient development workflows, proper management ensures that the right Java version is utilized for every project.
Importance of using specific Java versions
You must check that the Java version to be used is compatible with the application, program, or software running on the system. Using the appropriate Java version ensures that the product runs smoothly and without any compatibility issues.
Newer versions of Java usually come with updates and security fixes, which helps protect the system from vulnerabilities. Using an out-of-date Java version may expose the system to security vulnerabilities.
Performance enhancements and optimizations are introduced with every Java version. For maximum performance, use a Java version that is specific to the application.
Checking the current Java version
It is important to know which versions are installed on the system before switching to other Java versions. To check the current Java version, the java-common package has to be installed. This package contains common tools for the Java runtimes including the update-java-alternatives method. This method allows you to list the installed Java versions and facilitates switching between them. Use the following command to install the java-common package:
sudo apt-get install java-common
Upon completing the installation, verify all installed Java versions on the system using the command provided below:
sudo update-java-alternatives --list
The report above shows that Java versions 8 and 11 are installed on the system. Use the command below to determine which version is being used at the moment.
java -version
The displayed output indicates that the currently active version is Java version 11.
Installing multiple Java versions
Technically speaking, as long as there is sufficient disk space and the package repositories support it, the administrator of Ubuntu is free to install as many Java versions as they choose.
Follow the instructions below for installing multiple Java versions.
Begin by updating the system using the following command:
sudo apt-get update -y && sudo apt-get upgrade -y
To add another version of Java, run the command below.
sudo apt-get install <java version package name>
In this example, installing Java version 17 can be done by running:
sudo apt-get install openjdk-17-jdk openjdk-17-jre
Upon completing the installation, use the following command to confirm the correct and successful installation of the Java version:
sudo update-java-alternatives --list
Switching and setting the default Java version
To switch between Java versions and set a default version on Ubuntu Linux, you can use the update-java-alternatives command.
sudo update-java-alternatives --set <java_version>
In this case, the Java version 17 will be set as default:
sudo update-java-alternatives --set java-1.17.0-openjdk-amd64
To check if Java version 17 is the default version, run the command:
java -version
The output shows that the default version of Java is version 17.
Managing and Switching Java Versions in Ubuntu
Conclusion
In conclusion, managing multiple Java versions on Ubuntu Linux using update-java-alternatives is a simple yet effective process. By following the steps outlined in this article, users can seamlessly switch between different Java environments, ensuring compatibility with various projects and taking advantage of the latest features and optimizations offered by different Java versions. Because Java version management is flexible, developers may design reliable and effective Java apps without sacrificing system performance or stability.
22 August 2025 · 4 min to read
Linux
Linux cp Command
Linux has an unlimited set of commands to perform assigned tasks. The Linux cp command is the primary tool and the basis for copying and managing files and directories in this operating system. This function is designed to duplicate files or directories in the same or different location. Armed with this functionality, users have advanced capabilities: from creating backup copies to moving files between directories.
Linux cp command is simple to learn
You can find all the necessary information covered in this tutorial. You will discover how the Linux cp command and cp directory work, as well as its grammatical structures, crucial hints, parameters, settings, and recommended practices. Readers will learn the tricks of the cp command, which will help them become more proficient.
You can try our Linux VPS hosting for your projects.
The core of the cp command in Linux
The functionality of the command allows users to control the creation of copies. One feature offers overwriting existing files, another is responsible for recursively copying a directory with its entire entities, and the third protects the first data for repeating backups. This command demonstrates more features for specific purposes and user experience during the process.
A key benefit of the cp command is its exceptional accuracy in duplicating files and directories. You can be absolutely sure that the duplicated files are identical to the original ones with all its interior. Therefore, the user can replicate the original file without any changes. The cp command in Linux inherently tells the user a destination directory for storing copies in a specific repository. The command's precision makes it indispensable for both novice and advanced users.
Linux cp syntax
This command consists of the following parameters: source file or directory and destination directory. The basic syntax of the Linux cp command is as follows:
cp [...file/directory-sources] [destination]
Here [file/directory-sources] specifies the files or directories sources to copy, while the [destination] specifies the location to copy the file to.
There are the letter flags to specify the way of creation a replica of files and directories:
-a leaves the first file attributes the same;
-r recursively replicates directories and their interior entities;
-v shows copied files in detail;
-i requires consent to overwrite the file;
-u rewrites new or missing files in the destination directory;
-f forcibly copies without user consent;
-s makes a symbolic link instead of a file replica;
-ra recreates an exact duplicate of a file or directory without changing attributes;
-rf updates or changes a file or directory with the original name in the same place;
-pv (if installed) monitors and shows the time required to complete copying large folders.
How to copy files with the cp command
To make a file copy, apply the cp command in Linux as follows:
cp ./DirectoryA_1/README.txt ./DirectoryA_2
where ./DirectoryA_1/README.txt is the source file, and ./DirectoryA_2 is the destination.
The cp command was originally designed to interact with files. To replicate directories, you must use the -r flag to command that the directory with all its interior entities to be copied recursively. Therefore, you should write cp -r before the directory sources in Linux as follows:
cp -r ./DirectoryA_1/Folder/ ./DirectoryA_2
The cp -r command in Linux will recursively duplicate the Folder directory in ./DirectoryA_1/ as well as all contents in the Folder directory.
For instance, if you need to replicate the whole file contents in DirectoryA_1 with the .txt extension, try following command:
cp ./DirectoryA_1/*.txt ./DirectoryA_2
where ./DirectoryA_1/*.txt matches files with the .txt extension in their names, and the cp command duplicates all those data to the destination.
Best practices of the cp Linux command
To duplicate one unit of information via the Linux cp command, write down the file name and destination directory. For instance, to replicate a file named example.txt to the 'Documents' directory, try the following command:
cp example.txt Documents/
The action leads to creating a file duplicate in the 'Documents' directory with the original name.
To copy multiple files at once, utilize the cp command in Linux, specifying the file names separated by a space. For instance, to duplicate three files named 'file1.txt', 'file2.txt', and 'file3.txt' to the 'Documents' directory, try the following command:
cp file1.txt file2.txt file3.txt Documents/
To replicate a directory with all its interior entities, apply the -r that means cp recursive feature in Linux. For instance, to duplicate a directory named 'Pictures' to the 'Documents' directory, try the following command:
cp -r Pictures Documents/
The action leads to creating a copy of the 'Pictures' directory with all its interior contents in the 'Documents' directory.
To replicate a folder in Linux, you should utilize the -r flag. For instance, to duplicate a folder named 'Pictures' from the existing directory to a folder named 'Photos' in the home directory, try the following command:
cp -r Pictures/ ~/Photos/
The destination folder will be created automatically if none exists. The files in the destination folder will be combined with the core of the source folder if one already exists.
The cp -a feature in Linux leaves unchanged the initial file attributes while copying. Therefore, the duplicates will have the same parameters as their originals. For instance, to replicate a file named 'example.txt' to the 'Documents' directory while leaving unchanged its attributes, try the following command:
cp -a example.txt Documents/
The Linux cp -v function showcases the progress of the duplication. At the same time the user can copy large files while monitoring the process. For instance, to replicate a file named 'largefile.zip' to the 'Downloads' directory while watching the progress, try the following command:
cp -v largefile.zip Downloads/
The -i option requires the consent before overwriting an initial file. to protect against an accidental file rewriting. For instance, to duplicate a file named 'example.txt' to the 'Documents' directory, if a file with the identical name already exists, the cp command will require the consent before rewriting the original file.
Initially, the Linux cp command copies a file or a directory to a default location. The system allows the user to specify any other location for the duplicate file or directory. For instance, to replicate a file named 'example.txt' from the 'Documents' directory to the 'Downloads' directory, try the following command:
cp Documents/example.txt Downloads/
The cp -ra function in Linux is designed to carry out the copying process of directories with all their contents inside. The -r flag gives an order to repeat all the files and directories within an existing location, while the -a flag keeps the initial attributes preserved. Therefore, it is possible to make an exact duplicate of a directory without changing attributes.
For instance, if you apply the command cp -ra /home/user1/documents /home/user2, it will replicate the 'documents' directory with all its entities inside in the 'user2' directory. The new folder will show the identical attributes as the initial item.
The cp -rf feature in Linux is similar to the previous -ra option. The difference between these two functions is that the -f flag rewrites the given files or directories in the destination without requiring consent. Therefore, it is possible to update or replace an item with the identical name in the place of destination.
For instance, if you apply the command cp -rf /home/user1/documents /home/user2, and there is already a 'documents' directory in the 'user2' directory, it will be overwritten with the contents of the 'documents' directory from the 'user1' directory.
Be careful while utilizing the -rf function. Incorrect use of it leads to data loss. Check up twice the destination folder to avoid unwanted rewriting items.
It is simpler to work with files and directories when you use Linux's cp -r capability with the -a and -f settings. Whereas the -rf particle modifies or replaces files and directories, the -ra particle precisely copies a directory and everything within it. You can learn how to handle stuff in this operating system by properly applying these differences.
If you want to monitor and control the process of item duplication, which is not possible with other parameters of the cp command, use the -pv utility.
To install the pv utility on Debian/Ubuntu you need to open the terminal and run the following command:
apt-get install pv
After the installation is complete, verify it by running the following command in the terminal
pv --version
To install the pv utility on CentOS/Fedora, you need to connect the EPEL repository, which contains additional software packages unavailable in the default repositories. Run in the terminal:
yum install epel-release
Then run the following command in the terminal:
yum install pv
After the installation is complete, verify it by running the following command in the terminal:
pv --version
To use this particle with the cp command, you should utilize | symbol. You can use the ~ symbol to indicate the root directory if the full path needs to be specified.
For instance, to replicate a folder named 'Documents' from the root directory to a folder named 'Backup' in the home directory, try the following action:
cp -r Documents/ ~/Backup/ | pv
Example of executed Linux cp command
Conclusion
The cp command, although not an inherently difficult tool to learn, nevertheless provides basic knowledge of using the Linux operating system in terms of managing files and directories. In this tutorial, we tried to show the capabilities of the cp command in Linux from all sides, demonstrating best practices and useful tips of its various parameters. With new knowledge, you will be able to improve your skills in interacting with files and directories in Linux.
The extreme accuracy of the copying process and additional options allow you to solve a wide range of problems. Multifunctionality helps users choose the file management mode and complete tasks efficiently. The command is a prime example of the many capabilities of this operating system, including the cp with progress feature in Linux. Altogether they unlock a potential of the system for novice and advanced users.
22 August 2025 · 9 min to read
Do you have questions,
comments, or concerns?
Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
whether you need help or are just unsure of where to start.
