💎 Earn 45%—Join Hostman Affiliate Program!
How to Copy Files and Directories in Linux
Linux
07.02.2025
Reading time: 8 min
Share
When you first start working with Linux, one of the essential tasks you’ll encounter is file management. Whether you’re organizing your personal documents, migrating system files, or preparing comprehensive backups, knowing how to duplicate your files accurately is crucial. At the heart of this process is the cp command—a robust utility designed to replicate files and directories effortlessly.
This guide is designed to help you master the cp command. We’ll explore everything from basic file copying to recursive directory replication, along with tips for preserving file metadata and preventing accidental data loss. With detailed examples, real-world scenarios, and best practices, you’ll soon be equipped to use cp like a seasoned Linux professional.
Diving into the cp Command
In Linux, the cp command functions as your primary tool for copying data. Its versatility allows you to handle everything from a single file copy to mirroring complex directory structures with nested subfolders. Unlike graphical file managers, the cp command works entirely from the terminal, giving you precise control over every aspect of the copy process.
How It Works
At its simplest, cp takes a source file (or directory) and duplicates it to a new location. Its flexibility, however, lies in its options—flags that let you modify its behavior to suit your needs. Whether you’re preserving file permissions, ensuring no accidental overwrites occur, or copying entire folder trees, cp has a flag for every scenario.
Basic Command Structure
The cp command follows a simple format. Here’s the canonical syntax:
cp [options] source destinationcp: The command to initiate a copy.[options]: Additional parameters (flags) that control the behavior of the copy process.source: The file or directory you wish to duplicate.destination: The target location or filename for the copy.
This straightforward structure makes cp a favorite among system administrators and casual users alike.
Exploring Key Options
The true power of cp is unlocked through its myriad options. Let’s review some of the most useful ones:
-
Recursive Copying (
-ror-R): When you need to copy an entire directory—complete with all its subdirectories and files—the recursive flag is indispensable. It tellscpto traverse the directory tree, ensuring nothing is left behind. -
Interactive Mode (
-i): Safety first! The interactive option prompts you before replacing an existing file. This extra step is critical when you’re working with important data, as it minimizes the risk of accidental overwrites. -
Force Copy (
-f): Sometimes you need to override warnings and ensure the file is copied no matter what. The force flag does just that, replacing existing files without a prompt. Use this with caution. -
Preserve Attributes (
-p): File integrity matters, especially when dealing with permissions, timestamps, and ownership information. The preserve flag ensures that the new copy retains all of these attributes, making it perfect for backups or sensitive system files. -
Verbose Output (
-v): For a detailed view of what’s happening during the copy process, the verbose option prints each step to the terminal. This can be particularly helpful when copying large sets of files or debugging complex operations.
Practical Examples: Copying Files
Let’s now dive into some practical examples to see how these options come together in everyday tasks.
Copying a Single File
Imagine you have a file named notes.txt and you want to create a backup copy in the same directory. You can simply run:
cp notes.txt notes_backup.txtThis command creates an exact duplicate named notes_backup.txt. However, if a file by that name already exists and you want to avoid overwriting it without confirmation, you can use:
cp -i notes.txt notes_backup.txtThe -i flag ensures that you’re asked before any overwriting takes place.
Transferring Files Between Folders
If your goal is to move a file from one location to another, specify the destination directory. For instance, to move report.pdf to a directory called archive, use:
cp report.pdf /home/username/archive/Make sure that the destination directory already exists; cp will not create it for you. If it doesn’t, you can create it with the mkdir command beforehand.
Copying Multiple Files at Once
Sometimes, you might need to duplicate several files simultaneously. To copy file1.txt, file2.txt, and file3.txt into a directory named backup, you would type:
cp file1.txt file2.txt file3.txt /home/username/backup/This command handles multiple files in one go. If you’re dealing with many files that share a common pattern—say, all log files—you can use a wildcard:
cp *.log /home/username/logs/This instructs cp to copy every file ending with .log into the logs directory, streamlining the process when working with numerous files.
Mastering Recursive Copying for Directories
Often, the task isn’t limited to a single file but involves entire directories. Copying directories requires a recursive approach to capture every nested file and folder.
Recursively Duplicating a Directory
Suppose you want to duplicate a website’s content located in /var/www/html to create a backup. The command would be:
cp -r /var/www/html /backup/html_backupHere, the -r flag tells cp to copy everything within /var/www/html—subdirectories, hidden files, and all.
Combining Recursive and Preserve Options
When backing up directories, it’s often crucial to maintain file permissions, timestamps, and other metadata. In such cases, combine the recursive flag with the preserve flag:
cp -rp /var/www/html /backup/html_backupThis command ensures that every file in /var/www/html is copied to /backup/html_backup with all its original attributes intact. It’s an ideal solution for sensitive data or system configurations.
Tips, Tricks, and Advanced Techniques
Now that you understand the basics, let’s explore some advanced strategies and best practices for using the cp command effectively.
Combine Options for Enhanced Safety
It’s common to use multiple options together to tailor the behavior of cp. For instance, to safely copy a directory while preserving file attributes and prompting for overwrites, you can use:
cp -rpi /data/source_directory /data/destination_directoryThis powerful combination ensures a thorough and secure copy process.
Handling File Names with Special Characters
File names in Linux may include spaces or special characters. To ensure these names are handled correctly, enclose them in quotes. For example:
cp "My Important Document.txt" "My Important Document Copy.txt"This prevents the shell from misinterpreting spaces as delimiters between different arguments.
Avoiding Unintentional Overwrites
For batch operations or automated scripts, you might want to ensure that existing files are never overwritten. The -n option (short for no-clobber) achieves this:
cp -n *.conf /backup/configs/This command copies configuration files only if a file with the same name doesn’t already exist in the destination, adding an extra layer of safety.
Use Verbose Mode for Debugging
When dealing with a large volume of files or troubleshooting a copy operation, the verbose flag (-v) can be immensely helpful:
cp -rv /source/folder /destination/folderVerbose mode prints every file as it is processed, giving you a clear view of the ongoing operation and making it easier to identify any issues.
Real-World Applications and Scenarios
The cp command isn’t just for occasional use—it’s a vital tool in many professional settings. Here are a few real-world scenarios where mastering cp can make a significant difference:
System Administration and Backups
System administrators often use cp to create backups before making critical changes to system configurations. For instance:
cp -rp /etc /backup/etc_backupThis command creates a comprehensive backup of the /etc directory, preserving all system settings and permissions. In the event of an error or system failure, such backups are indispensable.
Data Migration and Server Transfers
When moving data between servers or different parts of a network, cp helps ensure that all files are transferred accurately. Combining cp with other tools like rsync can create robust solutions for data migration.
Development and Testing
Developers frequently duplicate directories to create test environments or sandbox copies of their projects. Whether you’re testing a new feature or debugging an issue, copying the entire project directory with preserved attributes can save you time and prevent potential errors.
Best Practices for Using cp Effectively
To wrap up, here are some key recommendations to keep in mind when using the cp command:
- Double-check Destination Paths: Always verify that the target directory exists to avoid errors during the copy process.
- Use Interactive Mode for Critical Files: When working with important data, the
-iflag can prevent unintentional overwrites by asking for confirmation. - Quote File Names with Spaces: Ensure that any file names containing spaces or special characters are enclosed in quotes.
- Plan Your Backup Strategy: Regularly back up essential directories using recursive and preserve options to maintain data integrity.
- Combine Options Thoughtfully: Mix and match flags such as
-r,-p, and-vto tailorcpto your specific needs, ensuring safety and clarity in your file operations.
Final Thoughts
The Linux cp command is a cornerstone of effective file management. Its simplicity belies the powerful functionality hidden within its many options. By mastering cp, you not only streamline your workflow but also protect your data through careful handling of file attributes, recursive copying, and thoughtful automation.
Whether you’re a novice stepping into the Linux world or an experienced user looking to refine your skills, the techniques and examples provided in this guide will serve as a reliable reference for your file duplication tasks. Remember to consult the manual page (man cp) for additional details and advanced options.
Embrace the versatility of the cp command, and soon you’ll find that managing files and directories on Linux becomes second nature.
Linux
07.02.2025
Reading time: 8 min
Share
Similar
Linux
How to Use Telnet Command on Linux
The telnet command is a great and handy Linux network service communication utility. From remote server and system port scans, to debugging network connections, telnet offers easy text-based interaction with a remote host.
In this step by step guide, you can see how to install, configure, and utilize telnet in Linux. We shall also discuss its various options and features so that you can have a complete idea.
What is Telnet?
telnet, or "Telecommunication Network," is a remote network protocol on another computer over the Transmission Control Protocol (TCP). telnet provides the ability to directly specify the remote host on a particular port so that commands may be sent and output directly read in real time.
telnet is employed primarily for:
Testing Open Ports: Determine if a server has an open port.
Accessing Services: Get direct access to the web, e-mail, or other networked services.
Troubleshooting Network Issues: Fix network connectivity issues or port not available issues.
Installing Telnet on Linux
telnet is not pre-installed on most modern Linux distributions. Installation depends on your system type.
For Ubuntu/Debian-Based Systems
An Ubuntu or any Debian-based Linux user can install telnet with the apt package manager:
sudo apt install telnet
For Red Hat/CentOS-Based Systems
telnet can be installed on RedHat, CentOS, or Fedora by using the yum or dnf package managers:
sudo yum install telnet
For newer versions:
sudo dnf install telnet
Understanding the Telnet Command Syntax
The telnet command syntax is simple:
telnet [hostname/IP] [port]
Where:
[hostname/IP]: Specifies the hostname or IP address of the remote host.
[port]: Specifies the port number you want to connect to. It can be omitted, and the default port (23) is used.
telnet establishes one direct connection to services on specific ports, like HTTP (port 80), SMTP (port 25), or FTP (port 21).
Different Options Available for the Telnet Command
The telnet command is highly customizable, offering several options that enhance its usability and functionality.
Option
Description
-4
Forces telnet to use IPv4 only when establishing a connection.
-6
Forces telnet to use IPv6 only when connecting.
-8
Allows transfer of 8-bit data via telnet.
-E
Disables the telnet escape character operation, disallowing escape sequences during the session.
-K
Prevents telnet from automatically passing credentials (e.g., a Kerberos ticket) to the remote host.
-L
Enables the loopback mode so that telnet can connect to the same host.
-X atype
Specifies the authentication type (i.e., KERBEROS_V4) to be used during the telnet session.
-a
Automatically fills in the user's login name attempting to log onto the remote system.
-d
Enables debugging mode, providing detailed information about the connection process and communication.
-e char
Alters the escape character for telnet.
-l user
Specifies the username for the login attempt.
-n tracefile
Writes session activity to a specified trace file for debugging or logging.
-b addr
Defines a local interface or address for telnet to use when connecting.
-r
Creates a reverse telnet connection.
Using Telnet: Practical Applications
telnet provides diagnostic and testing capabilities for networks. Some of these include:
Test Open Ports
telnet is often used to verify if a specified port of a server is open. To verify port 80, enter the following command:
telnet example.com 80
If the port is open, telnet will connect, and you might have a blank screen expecting input. This is a good indication that the port is listening and expecting to chat. If the port is firewalled or closed, you would get an error message such as "Connection refused."
Interact with SMTP Servers
telnet can debug email servers by sending raw SMTP commands. To open an SMTP server on port 25:
telnet mail.example.com 587
Once connected, you can directly type SMTP commands such as HELO, MAIL FROM, and RCPT TO to communicate with the server. For example:
Send HTTP Requests
telnet enables manual HTTP requests to debug web servers. For example:
telnet example.com 80
After connecting, type:
GET / HTTP/1.1
Host: example.com
Press Enter twice to send the request, and the server's response will appear.
Connect Using IPv4
If the server supports both IPv4 and IPv6, you can force the connection to use IPv4:
telnet -4 example.com 80
This ensures compatibility with IPv4-only networks.
Debugging a MySQL Server
telnet can connect to a MySQL database server to check if the port is open (default port 3306).
telnet database.example.com 3306
Replace database.example.com with the MySQL server address.
If the connection is successful, telnet will display a protocol-specific greeting message from the MySQL server.
Security Considerations When Using Telnet
Although telnet is a handy utility, it is fundamentally unsafe since it sends the data, including passwords, in cleartext. Consequently:
Don't Use Telnet Over Unsecure Networks: Utilize a secure, private network whenever possible.
Use Alternatives: Use SSH (Secure Shell) for encrypted communication.
Restrict Access: Turn off telnet on your servers if you do not use it.
By understanding these risks, you can take precautions to secure your systems.
Exploring Advanced Telnet Use Cases
telnet’s utility extends to a variety of specialized scenarios:
Monitoring Services: Use telnet to interactively query protocols like IMAP or POP3 to diagnose emails.
IoT Device Management: telnet can be utilized as an immediate interface to communicate with IoT devices that utilize text-based communication protocols.
Educational Use: It is an excellent learning tool for studying network protocols and server responses.
Troubleshooting Common Telnet Issues
Despite its simplicity, telnet may run into issues such as:
Connection Refused: This would usually be so if the target port is firewalled or closed.
Time-Out Errors: These could reflect network delay or routing issues.
Permission Denied: Check appropriate user privilege and port availability.
Regularly checking server configurations and network settings can help resolve these issues.
Exploring Telnet Alternatives
If telnet's lack of encryption is a security risk to your system, there are several alternatives that offer comparable functionality with added security and features:
SSH (Secure Shell): SSH is the most common telnet substitute, providing secured communication, tunneling, and strong authentication. Use the ssh command to securely connect to remote servers.
Netcat (nc): Netcat is a full-featured networking debugging tool, port scanner, and connection tester. It can handle both TCP and UDP.
OpenSSL S_client: OpenSSL can be utilized to test SSL/TLS protocols securely on particular ports.
Conclusion
telnet in Linux is a simple and convenient network diagnostics and debugging tool. As long as you understand its security limitation and have sufficient configurations, telnet remains a convenient debugging tool, test tool, and communications tool for network services.
From this guide, you have a working configuration that strikes a balance between convenience and responsible caution. Get the best out of your Linux experience and control your systems securely and efficiently remotely.
24 July 2025 · 6 min to read
Linux
How to Set Up Backup with Bacula
Bacula is a cross-platform client-server open source backup software that enables you to back up files, directories, databases, mail server data (Postfix, Exim, Sendmail, Dovecot), system images, and entire operating systems.
In this guide, we’ll walk you through the process of installing and configuring Bacula on Linux, as well as creating backups and restoring user data.
To get started with Bacula, you’ll need a server or virtual machine running any Linux distribution. In this tutorial, we’ll be using a cloud server from Hostman with Debian 12.
Bacula Architecture
Bacula’s architecture consists of the following components:
Director (Bacula Director)
The core component responsible for managing all backup, restore, and verification operations. The Director schedules jobs, sends commands to other components, and writes information to the database.
Storage Daemon (Bacula Storage)
Handles communication with storage devices such as disks, cloud storage, etc. The Storage Daemon receives data from the File Daemon and writes it to the configured storage medium.
File Daemon (Bacula File)
The agent installed on client machines to perform the actual backup operations.
Catalog
A database (MySQL, PostgreSQL, or SQLite) used by Bacula to store information about completed jobs, such as backup metadata, file lists, and restore history.
Console (Bacula Console, bconsole)
A command-line utility for interacting with Bacula. The Console allows administrators to control the Director via a CLI. GUI tools such as Bacula Web and Baculum are also available.
Monitor (Optional)
A component for monitoring the Bacula system status. It tracks job statuses, daemon states, and storage device conditions.
Creating Test Data for Backup
Let’s create some test files to use in our backup.
Create a test directory and navigate into it:
mkdir /root/test_backups && cd /root/test_backups
Now create six sequential files:
touch file{1..6}.txt
Also, create a directory in advance for storing restored files:
mkdir /root/restored-files
Installing Bacula
In this tutorial, we will install all Bacula components on a single server. However, Bacula also supports a distributed setup where components such as the Director, Storage Daemon, Client, and database can be installed on separate servers. This decentralized setup is suitable for backing up multiple systems without overloading a single server.
We'll be using Debian 12 and installing PostgreSQL (version 15) as the backend database.
Update the package index and install Bacula (server and client components):
apt update && apt -y install bacula-server bacula-client
PostgreSQL 15 will also be installed during this process.
During installation:
When prompted with: “Configure database for bacula-director-pgsql with dbconfig-common?”, press ENTER.
When asked to choose the database host, select localhost, since we are installing everything on one server.
When prompted with: “PostgreSQL application password for bacula-director-pgsql”, set a password for the Bacula database.
Do not leave this field empty, or a random password will be generated.
Re-enter the password when asked to confirm.
The installation will then continue normally.
After the installation is complete, verify the status of Bacula components and PostgreSQL.
Check the status of the Bacula Director:
systemctl status bacula-director
Check the Storage Daemon:
systemctl status bacula-sd
Check the File Daemon:
systemctl status bacula-fd
Check PostgreSQL:
systemctl status postgresql
If all components display a status of active, then Bacula has been successfully installed and is running.
Bacula Configuration
Bacula is configured by editing the configuration files of the program components. By default, all Bacula configuration files are located in the /etc/bacula directory.
Next, we will configure each Bacula component individually.
Configuring Bacula Director
Using any text editor, open the bacula-dir.conf configuration file for editing:
nano /etc/bacula/bacula-dir.conf
Let’s start with the Director block, which sets the main configuration parameters for the Director component:
Director {
Name = 4142939-bi08079-dir
DIRport = 9101
QueryFile = "/etc/bacula/scripts/query.sql"
WorkingDirectory = "/var/lib/bacula"
PidDirectory = "/run/bacula"
Maximum Concurrent Jobs = 20
Password = "ohzb29XNWSFISd6qN6fG2urERzxOl9w68"
Messages = Daemon
DirAddress = 127.0.0.1
}
Explanation of parameters:
Name: The name of the Director component. This is a unique identifier used to connect with other components like the File Daemon and Storage Daemon. By default, it includes the server's hostname and the -dir suffix. Example: 4142939-bi08079-dir.
DIRport: The port that Bacula Director listens to for incoming connections from the management console (bconsole). Default is 9101.
QueryFile: Path to the SQL script file used to run queries on the database. It contains predefined SQL queries for job management, verification, data restoration, etc. Default: /etc/bacula/scripts/query.sql.
WorkingDirectory: The working directory where Bacula Director temporarily saves files during job execution.
PidDirectory: The directory where the Director saves its PID file (process identifier). This is used to track if the process is running.
Maximum Concurrent Jobs: The maximum number of jobs that can run simultaneously. The default is 20.
Password: Password used for authenticating the management console (bconsole) with the Director. Must match the one specified in the console’s configuration.
Messages: Specifies the name of the message resource that determines how messages (errors, warnings, events) are handled. Common values: Daemon, Standard, Custom.
DirAddress: The IP address the Director listens on. This can be 127.0.0.1 for local connections or an external IP.
Catalog Configuration
By default, Bacula comes with its own PostgreSQL instance on the same host, and in that case, database connection settings don’t need changes. But if you're deploying the database separately (recommended for production), the address, username, and password must be specified in the Catalog block:
Catalog {
Name = MyCatalog
dbname = "bacula"; DB Address = "localhost"; dbuser = "bacula"; dbpassword = "StrongPassword4747563"
}
Explanation of parameters:
dbname: The name of the database used by Bacula (default is bacula). The database must already exist (when deployed separately).
DB Address: Host address where the DBMS is deployed. Use IP or a domain name. For local setup: localhost or 127.0.0.1.
dbuser: The user Bacula will use to connect to the database.
dbpassword: Password for the specified database user. Must be preconfigured.
Restore Job Configuration
Locate the Job block named RestoreFiles, responsible for file restoration. Set the Where parameter to specify the directory where restored files will be saved. Earlier, we created /root/restored-files, which we’ll use here:
Job {
Name = "RestoreFiles"
Type = Restore
Client=4244027-bi08079-fd
Storage = File1
# The FileSet and Pool directives are not used by Restore Jobs
# but must not be removed
FileSet="Full Set"
Pool = File
Messages = Standard
Where = /root/restored-files
}
Backup Schedule Configuration
Next, we set up the Schedule block that defines when backups are created.
We create:
A full backup every Monday at 00:01.
A differential backup every Sunday (2nd to 5th week) at 23:05.
An incremental backup daily at 23:00:
Schedule {
Name = "WeeklyCycle"
Run = Full 1st mon at 00:01
Run = Differential 2nd-5th sun at 23:05
Run = Incremental mon-sun at 23:00
}
FileSet Configuration
Now, we specify which files and directories will be backed up. This is defined in the FileSet block. Earlier we created /root/test_backups with six files. We’ll specify that path:
FileSet {
Name = "Full Set"
Include {
Options {
signature = MD5
}
File = /root/test_backups
}
}
Explanation of parameters:
Name: The name of the FileSet block, used for identification in configuration.
Options: Settings that apply to all files listed under Include.
signature = MD5: Specifies the checksum algorithm used to verify file integrity. MD5 generates a 128-bit hash to track file changes.
Exclude Configuration (Optional)
The Exclude block is used to specify files or directories that should not be backed up. This block is placed inside the FileSet definition and acts on files included via Include.
Exclude {
File = /var/lib/bacula
...
}
Pool Configuration
The Pool block defines a group of volumes (storage units) used for backup. Pools help manage how data is stored, rotated, and deleted.
Pool {
Name = Default
Pool Type = Backup
Recycle = yes
AutoPrune = yes
Volume Retention = 7 days
Maximum Volume Bytes = 10G
Maximum Volumes = 2
}
Explanation of parameters:
Name: The pool's name, here it's Default.
Pool Type: Defines the pool's function:
Backup: Regular backups.
Archive: Long-term storage.
Cloning: Data duplication.
Recycle: Indicates whether volumes can be reused once they're no longer needed (yes or no).
AutoPrune: Enables automatic cleanup of expired volumes.
Volume Retention: How long (in days) to retain data on a volume. After 7 days, the volume becomes eligible for reuse.
Maximum Volume Bytes: The max size for a volume. If it exceeds 10 GB, a new volume is created (if allowed).
Maximum Volumes: Limits the number of volumes in the pool. Here, it's 2. Older volumes are recycled when the limit is hit (if Recycle = yes).
Validating Configuration and Restarting Bacula
After making all changes, check the bacula-dir.conf file for syntax errors:
/usr/sbin/bacula-dir -t -c /etc/bacula/bacula-dir.conf
If the command output is empty, there are no syntax errors. If there are errors, the output will specify the line number and error description.
Restart the Bacula Director service:
systemctl restart bacula-director
Configuring Bacula Storage
The next step is configuring Bacula Storage, where the backup files will be stored.
Using any text editor, open the configuration file bacula-sd.conf for editing:
nano /etc/bacula/bacula-sd.conf
We'll start with the Storage block, which defines the storage daemon responsible for physically saving backup files:
Storage {
Name = 4149195-bi08079-sd
SDPort = 9103
WorkingDirectory = "/var/lib/bacula"
Pid Directory = "/run/bacula"
Plugin Directory = "/usr/lib/bacula"
Maximum Concurrent Jobs = 20
SDAddress = 127.0.0.1
}
Here’s what each parameter means:
Name: Name of the storage daemon instance, used to identify it uniquely.
SDPort: Port number the Storage Daemon listens on. The default is 9103.
WorkingDirectory: Working directory for temporary files. Default: /var/lib/bacula.
Pid Directory: Directory to store the PID file (process ID) for the storage daemon. Default: /run/bacula.
Plugin Directory: Path where Bacula’s plugins for the storage daemon are located. These plugins can provide extra features such as encryption or cloud integration.
Maximum Concurrent Jobs: Maximum number of jobs the storage daemon can handle simultaneously.
SDAddress: IP address the Storage Daemon is available at. This can be an IP or a domain name. Since in our case the Storage Daemon runs on the same server as the Director, we use localhost.
The next block to configure is Device, which defines the storage device where backups will be written.
The device can be physical (e.g., a tape drive) or logical (e.g., a directory on disk). For testing, one Device block will suffice. By default, bacula-sd.conf may contain more than one Device block, including a Virtual Autochanger — a mechanism that emulates a physical autochanger (used for managing tapes or other media). It lets you manage multiple virtual volumes (typically as disk files) just like real tapes in a tape library.
Locate the Autochanger block and remove the FileChgr1-Dev2 value from the Device parameter:
Autochanger {
Name = FileChgr1
Device = FileChgr1-Dev1
Changer Command = ""
Changer Device = /dev/null
}
Next, in the Device block below, specify the full path to the directory we previously created for storing backup files (/srv/backup) in the Archive Device parameter:
Device {
Name = FileChgr1-Dev1
Media Type = File1
Archive Device = /srv/backup
LabelMedia = yes;
Random Access = Yes;
AutomaticMount = yes;
RemovableMedia = no;
AlwaysOpen = no;
Maximum Concurrent Jobs = 5
}
Any blocks referencing FileChgr2 and FileChgr1-dev2 should be deleted:
Explanation of the parameters:
Autochanger Block:
Name: Identifier for the autochanger (you can have multiple).
Device: Name of the device linked to this autochanger—must match the Device block name.
Changer Command: Script or command used to manage the changer. An empty value ("") means none is used—suitable for virtual changers or simple setups.
Changer Device: Refers to the device tied to the autochanger, typically for physical devices.
Device Block:
Name: Identifier for the device.
Media Type: Media type associated with the device. Must match the Pool block media type.
Archive Device: Full path to the device or directory for storing backups; /srv/backup in this case.
LabelMedia: Whether Bacula should auto-label new media.
Random Access: Whether random access is supported.
AutomaticMount: Whether to auto-mount the device when used.
RemovableMedia: Specifies if the media is removable.
AlwaysOpen: Whether the device should always stay open.
Maximum Concurrent Jobs: Maximum number of simultaneous jobs using this device.
Since we previously specified the directory for backup storage, create it:
mkdir -p /srv/backup
Set the ownership to the bacula user:
chown bacula:bacula /srv/backup
Next, check the config file for syntax errors:
/usr/sbin/bacula-sd -t -c /etc/bacula/bacula-sd.conf
If there are no syntax errors, the output will be empty. Otherwise, it will indicate the line number and description of any error.
Restart the storage daemon:
systemctl restart bacula-sd
Creating a Backup
Backups in Bacula are created using the bconsole command-line tool. Launch the utility:
bconsole
If it connects to the Director component successfully, it will display 1000 OK.
Before running a backup, you can check the status of all components by entering the command:
status
This will display a list of the five Bacula system components. To check them all, enter 6.
To initiate a backup, enter the command:
run
From the list, choose the BackupClient1 option (your client name might differ based on previous config), by typing 1.
After selecting the option, you’ll see detailed info about the backup operation.
You’ll then be prompted with three choices:
yes — start the backup process;
mod — modify parameters before starting;
no — cancel the backup.
If you enter mod, you’ll be able to edit up to 9 parameters.
To proceed with the backup, type yes.
To view all backup and restore jobs and their statuses:
list jobs
In our case, a backup with Job ID 1 was created:
list jobid=1
If the status is T, the backup was successful.
Possible statuses in the "Terminated Jobs" column:
T (Success) — Job completed successfully.
E (Error) — Job ended with an error.
A (Canceled) — Job was canceled by the user.
F (Fatal) — Job ended due to a critical error.
R (Running) → Terminated — Job completed (may be successful or not).
You can also monitor backup activity and errors via the log file:
cat /var/log/bacula/bacula.log
Once the backup finishes, the file will be saved in the specified directory.
file Vol-0001
Restoring Files from Backup
Earlier, we backed up the /root/test_backups directory, which contained six .txt files. Suppose these files were lost or deleted. Let’s restore them:
Launch the Bacula console:
bconsole
Start the restore process:
restore
You’ll see 12 available restore options.
We’ll use option 3. Type 3.
Earlier we used Job ID 1 for our backup. Enter 1.
You’ll enter a file selection mode. Since our files were in the root/test_backups directory, navigate there.
All previously saved files should be visible.
To restore the whole directory, go up one level:
cd ..
Then mark the whole test_backups folder:
mark test_backups/
Finish selection:
done
The system will display a final summary showing which data will be restored and the target directory (in our case: /root/restored-files).
To start the restore, enter yes.
Finally, verify that the files have been successfully restored.
Conclusion
We’ve now reviewed the installation and configuration of Bacula, a client-server backup solution. Bacula isn’t limited to backing up regular files—thanks to its plugin support, it can also handle backups of virtual machines, OS images, and more.
18 July 2025 · 14 min to read
Linux
Installing Arch Linux in a Cloud Environment
Arch Linux is a lightweight and flexible Linux distribution that provides users with extensive opportunities for customizing and optimizing their systems. It includes a minimal amount of preinstalled software and offers a console-based interface. In most cases, it is used by experienced users: professional developers, system administrators, or hackers. This is due to the complexity of its installation and subsequent configuration, which involves adding the required packages and components to the system. However, these difficulties are justified, because in the end the user gets exactly the system and services they need.
In this article, we will explain how to install Arch Linux on your cloud server and perform its basic configuration.
Advantages of Arch Linux
It is worth noting that Arch Linux is ideally suited as an OS for a cloud server due to its low resource requirements. This distribution also has several other advantages:
System UpdatesArch Linux updates automatically when a new OS version is released.
Software InstallationPackages can be downloaded both over the network and from a local disk. In addition, the installed software does not need to be specifically compatible with Arch Linux.
Rich RepositoriesArch Linux offers a wide variety of packages. Today, there are over 12,000 packages in the official repositories alone. In the community repository, there are even more — over 83,000.
Up-to-date DocumentationThe official Arch Linux documentation is actively updated to reflect the latest changes and innovations. This ensures accurate and relevant system information.
Active CommunityThis distribution has an active user community ready to help and share their experience. There are many forums, wikis, and repositories where you can find detailed instructions and guides for installation, configuration, and troubleshooting.
1. Preparing for Installation
To follow this guide and install Arch Linux, you will need:
A cloud server with any operating system (in our case, Debian 11);
A link to the Arch Linux image from an official source;
An additional disk, which you can attach under the Plan tab in the control panel.
Step 1. To install Arch Linux on the server, you must first upload its installation image from an official source in .iso format. For example:
wget https://mirror.rackspace.com/archlinux/iso/2025.06.01/archlinux-2025.06.01-x86_64.iso
Step 2. Next, add a new disk where the installation image will be stored. It will appear in the system as /dev/sdb. You can specify the minimum disk size.
Step 3. Write the installation image to the new disk:
dd if=archlinux-2025.06.01-x86_64.iso of=/dev/sdb
The writing process will take some time. When finished, verify it with the following command:
fdisk -l
In the output, you will see that the installation image has been written to the new disk, creating two necessary partitions.
Step 4. After writing the installation image, proceed to boot from it. To do this, go to the Access tab and boot the server from the recovery disk. Open the console in the control panel.
Step 5. In the console window, go to the Boot existing OS menu item and press Tab on your keyboard. This will allow you to edit the text at the bottom of the screen. Here, you need to manually replace hd0 with hd1, as shown in the figure below.
After that, press Enter to launch the installation program.
Step 6. In the system bootloader that appears, select the first option.
2. Partitioning the Disk
Now we can partition the main disk (sda). In our case, there will be 3 partitions: a 300 MB UEFI partition (type EFI), a 700 MB swap partition (type Linux swap), and a main filesystem partition taking up all remaining space (type Linux). In your own installation, the number and size of partitions may differ depending on your requirements.
Make sure there are no important files on the server’s disk, because it will be formatted later. You may also wish to back it up to preserve important data.
Step 1. First, check whether there are any files on the disk you need to save:
lsblk
The screenshot below shows the list. For creating the described partitions, we will use a 25 GB disk — sda. It currently has Debian 11 installed, which does not contain important files.
Step 2. To partition the disk, enter the following command:
cfdisk /dev/sda
Step 3. In the window that opens, you need to delete all existing partitions. To do this, select a partition and use the Delete button in the lower menu.
Step 4. Next, select the New button in the lower menu to create a new partition.
Step 5. Then specify the size of the partition to be created. In our case, this is 300 MB for UEFI.
Step 6. In the next window, choose Primary.
Step 7. The partition is now created, and you need to specify its type. Go to the Type menu and select EFI.
Step 8. Now move to the Free space and create 2 more partitions, repeating steps 4 through 7. Partition details were listed at the beginning of this chapter.
Step 9. Once all partitions have been created, go to the Write button and select it. To confirm, type yes in the field that appears.
Step 10. Partitioning is now complete. To exit the tool, select the Quit button in the lower menu.
Step 11. You can verify your work using the lsblk command again.
Check in the output that all changes have been successfully applied.
3. Formatting and Mounting the Created Partitions
At this stage, the created partitions will be formatted and mounted. Remember, all data will be erased in this process!
Step 1. For the first partition, format it using the following command:
mkfs.fat -F32 /dev/sda1
This command will create a FAT32 filesystem, which is the recommended format for the UEFI partition.
Step 2. Next, assign it a mount point:
mkdir /mnt/efi
mount /dev/sda1 /mnt/efi
Step 3. For the second partition, perform special formatting:
mkswap /dev/sda2
Step 4. Then activate the swap partition:
swapon /dev/sda2
Step 5. Finally, format the system’s root partition:
mkfs.ext4 /dev/sda3
Step 6. After formatting, create its mount point:
mount /dev/sda3 /mnt
After completing the formatting and mounting, your partitions will be ready for installing and configuring Arch Linux and its main components.
4. Installing the Main Arch Linux Components
Step 1. First, let’s install the OS and its core components:
pacstrap /mnt base linux grub openssh nano dhcpcd
Step 2. Once the installation finishes, you need to generate the fstab file:
genfstab -U /mnt >> /mnt/etc/fstab
Generating the fstab file makes partition mounting management easier and ensures automatic and consistent mounting at system startup.
5. System Configuration
Step 1. To configure Arch Linux after installation, you need to chroot into the OS without rebooting:
arch-chroot /mnt
Step 2. First, install the nano text editor:
pacman -S nano
Step 3. Uncomment the encoding for English in the relevant file (you would edit locale.gen):
nano /etc/locale.gen
Uncomment the line for en_US.UTF-8.
After this, save the changes and exit nano, then generate the locales:
locale-gen
To enable the English language, execute:
echo "LANG=en_US.UTF-8" > /etc/locale.conf
Step 4. At this step, set up the system clock. For example:
ln -sf /usr/share/zoneinfo/Europe/Nicosia /etc/localtime
The region is set. Now synchronize the hardware clock:
hwclock --systohc
Step 5. Next, set the hostname for your system:
echo "hostname" > /etc/hostname
Step 6. As the second-to-last step, set the root password. Run:
passwd
You will be prompted to enter and confirm the password.
Step 7. Lastly, set up the previously installed GRUB bootloader to boot the server:
grub-install --target=i386-pc /dev/sda
Then create the GRUB configuration file:
grub-mkconfig -o /boot/grub/grub.cfg
This command will automatically configure GRUB.
Step 8. Arch Linux is now successfully installed. Exit the chroot:
exit
Then go to the Access tab in your control panel and switch the server to standard boot mode. After that, click Save and Reboot.
You can remove the additional disk after this step.
Step 9. The system will boot, but it is not ready for use yet. First, connect to the server and enable the DHCP client daemon:
systemctl enable dhcpcd
Then start it:
systemctl start dhcpcd
Make sure the service shows the status active (running).
Step 10. Next, configure the SSH connection. First, create a backup of the sshd configuration:
cp /etc/ssh/sshd_config /etc/ssh/backup.sshdconf
Then set PermitRootLogin to Yes in the /etc/ssh/sshd_config file:
nano /etc/ssh/sshd_config
Finally, enable the SSH daemon:
systemctl enable sshd
And start it:
systemctl start sshd
When checking with systemctl status sshd, the service should show active (running) status.
Don’t forget to add and configure SSH keys before connecting to the server.
6. Additional Configuration
The installation is complete, but you can also perform additional system configuration by reviewing the official Arch Linux setup documentation.
To install packages, use the command:
pacman -S package_name
To update the system, use:
pacman -Suy
Conclusion
In this guide, we reviewed the process of installing Arch Linux on your cloud server and performed its basic configuration. We used a temporary Debian 11 OS and an additional disk for the installation image. By following these steps, you can create a powerful and flexible virtual environment for developing, testing, and running applications based on Arch Linux.
03 July 2025 · 8 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.
