How To Create Tar.Gz File in Linux with Easy Steps

This guide intends to teach you How To Create Tar.Gz File in Linux. Tar is a powerful archiver that is frequently used for collecting files and archiving them. It was created to produce archives for data storage on tapes, thus the name “Tape Archive”. It was initially included in UNIX version 7 in 1979, and it is currently accessible on a variety of systems.

You can now follow the guide steps below on the Orcacore website to learn How To Create Tar.Gz File in Linux.

To complete this guide, you must log in to your Linux server as a root or non-root user with sudo privileges and follow the steps below.

General Syntax of Making a Tar File

The general syntax of making a tar file is shown below:

tar [options] [archive-file] [file(s) or directory(s) to archive]

Make Tar File in Linux

At this point, you can follow the steps below to create your tar.gz file.

For example, to create an archive named “archive.tar.gz” from “file1” and “file2” you would use the following command:

tar -czf archive.tar.gz file1 file2

On success, the command doesn’t print any output. To verify that the archive is created, list the directory contents with ls.

If you want to create the tar.gz in a specific directory, provide a full path to the archive file:

tar -czf /home/user/archive.tar.gz file1 file2

Also, you can create tar.gz files from the contents of one or more directories or files. By default, directories are archived recursively unless --no-recursion option is specified.

The following example shows how to create an archive named “web_backup.tar.gz” of the /var/www/website directory:

tar -czf web_backup.tar.gz /var/www/website

If you are running a system that has an older version of tar that doesn’t support compression, you can use the gzip command:

tar -czf - file1 file2 | gzip > archive.tar.gz

In the example above, the tar command outputs the archive to stdout (represented by -). The archive is piped to gzip, which compresses and writes the archive to the disk.

These are the basic uses of making a tar file in Linux.

Conclusion

At this point, you have learned to Create a tar.gz file in Linux. A Tar.gz file is a compressed archive used in Linux to bundle multiple files into one (.tar) and then compress them using Gzip (.gz). This makes it easier to store, transfer, and back up files while saving disk space.

Hope you enjoy it. Please subscribe to us on Facebook, YouTube, and Twitter.

Also, you may like these articles:

How To Create a New Account on CWP

Add a Package on Centos Web Panel (CWP)

Install CloudLinux on DirectAdmin

FAQs

Alternative Solutions for Creating Tar.Gz Files

While the tar command offers a robust and widely used method for creating .tar.gz files, alternative approaches exist that might be preferable in specific scenarios. These alternatives often leverage different tools or offer more streamlined workflows. Let’s explore two such solutions: using a file manager with archive capabilities and scripting with Python’s shutil library.

1. Using a File Manager with Archive Capabilities

Many graphical file managers in Linux environments (such as Nautilus in GNOME, Dolphin in KDE, or Thunar in XFCE) provide built-in archive creation capabilities. This approach is particularly user-friendly for those who prefer a visual interface. The steps generally involve:

1. Selecting Files/Folders: Open your file manager and navigate to the directory containing the files and folders you want to archive. Select the desired items.
2. Right-Click and Archive: Right-click on the selected items. A context menu should appear, offering an "Archive," "Compress," or similar option.
3. Choose Archive Format: A dialog box will appear, allowing you to specify the archive format (e.g., .tar.gz, .zip, .7z). Select .tar.gz (or .tar.gz2 for bzip2 compression, although .tar.gz is more common).
4. Name and Location: Enter the desired name for your archive file and choose the location where you want to save it.
5. Create Archive: Click the "Create" or "Compress" button to initiate the archive creation process.

Advantages:

• Ease of Use: Very intuitive for users familiar with graphical interfaces.
• No Command-Line Knowledge Required: Eliminates the need to memorize or type commands.
• Visual Confirmation: Provides visual feedback throughout the process.

Disadvantages:

• Limited Automation: Not suitable for automated scripting or batch processing.
• GUI Dependency: Requires a graphical environment.
• Potentially Slower: Might be slower than command-line tar for large archives.

Case Study:

Imagine a user, Sarah, who is new to Linux and needs to back up her "Documents" folder. She uses Ubuntu, which comes with Nautilus as its default file manager. She simply opens Nautilus, navigates to her "Documents" folder, selects all the files and subfolders within, right-clicks, chooses "Compress," selects ".tar.gz" as the format, names the archive "Documents_backup.tar.gz," and clicks "Create." The file manager handles the rest, creating the compressed archive without Sarah needing to use the command line.

2. Scripting with Python’s shutil Library

Python’s shutil library provides a higher-level interface for file operations, including archive creation. This approach is ideal for automating the process of How To Create Tar.Gz File in Linux within scripts or applications.

import shutil
import os

def create_targz(source_dir, output_filename):
    """Creates a tar.gz archive from a directory.

    Args:
        source_dir (str): The directory to archive.
        output_filename (str): The name of the output archive file (e.g., "archive.tar.gz").
    """
    try:
        shutil.make_archive(output_filename.replace(".tar.gz", ""), 'gztar', root_dir=os.path.dirname(source_dir), base_dir=os.path.basename(source_dir))
        shutil.move(output_filename.replace(".tar.gz", ".tar.gz"), output_filename)
        print(f"Successfully created archive: {output_filename}")
    except Exception as e:
        print(f"Error creating archive: {e}")

# Example Usage:
source_directory = "/var/www/website"
archive_name = "web_backup.tar.gz"
create_targz(source_directory, archive_name)

Explanation:

1. Import shutil: Imports the necessary library.
2. shutil.make_archive(): This function does the heavy lifting.
   • The first argument is the base name of the archive file (without the extension). The replace function is used to derive this from the intended output filename.
   • The second argument specifies the archive format (‘gztar’ for .tar.gz).
   • root_dir specifies the directory to start archiving from.
   • base_dir specifies the directory relative to root_dir to archive. This is important to get the correct directory structure in the archive.
3. Error Handling: The try...except block handles potential errors during the archive creation process.

Advantages:

• Automation: Easily integrated into scripts and automated workflows.
• Flexibility: Allows for customization and integration with other Python code.
• Cross-Platform Compatibility: shutil is part of the Python standard library, making it cross-platform.

Disadvantages:

• Requires Python Knowledge: Requires basic Python programming skills.
• Less Intuitive: Not as immediately obvious as using a file manager.

Case Study:

A system administrator, David, needs to automate daily backups of a website’s data. He writes a Python script that uses the create_targz function to create a .tar.gz archive of the website’s directory every night. He then schedules the script to run using cron, ensuring that the backups are performed automatically without manual intervention. The script provides consistent and reliable backups, freeing up David’s time for other tasks.

In conclusion, while the tar command remains a powerful and versatile tool for creating .tar.gz files, file managers and Python’s shutil library offer viable alternatives that cater to different user preferences and automation needs. Choosing the right approach depends on the specific requirements of the task at hand and the user’s comfort level with different tools and technologies. Learning How To Create Tar.Gz File in Linux via multiple avenues provides a more complete understanding of system administration. The best method is the one that fits the unique scenario.