DEV Community: saeedeldeeb

Efficient PostgreSQL Database Backup and Restoration with pg_dump and pg_restore

saeedeldeeb — Thu, 24 Aug 2023 09:40:51 +0000

In the world of database management, the ability to secure and swiftly restore data is paramount. PostgreSQL, a powerful open-source relational database management system, equips us with tools like pg_dump and pg_restore to ensure data integrity and efficient recovery. In this article, we will explore the seamless process of exporting and importing PostgreSQL databases using these utilities.

Exporting Data with pg_dump

To back up your PostgreSQL database, the pg_dump command comes to the rescue. This versatile tool allows you to create a comprehensive backup of your database, encompassing its structure and data. Here's how you can use it:

docker exec -i postgresql pg_dump --username=your-user --dbname=your-db --port=5478 -F c > /path/to/database/file.dump

Let's break down the command:

docker exec -i postgresql: Executes a command within the Docker container named postgresql.
pg_dump: Initiates the backup process.
--username=your-user: Specifies the username for database access.
--dbname=your-db: Specifies the name of the target database.
--port=5478: Specifies the port number for database connection.
-F c: Specifies the custom format for the backup.
> /path/to/database/file.dump: Redirects the backup output to a file named file.dump.

Importing Data with pg_restore

When it's time to restore your backup, pg_restore is your go-to utility. It efficiently brings back your database to life using the backup file created with pg_dump. The process is seamless:

docker exec -i postgresql pg_restore --username=your-user --dbname=your-db --port=5478 -c -F c < /path/to/database/file.dump

Breaking down the command:

--username=your-user, --dbname=your-db, and --port=5478 specify the same connection details used during backup.
-c cleans the existing database content before restoration.
-F c indicates that the format of the input is custom.
< //path/to/database/file.dump provides the backup file as input for the restoration process.

The Advantage of pg_restore

While both psql and pg_restore can restore .sql files, pg_restore boasts a substantial speed advantage. It is optimized to process backups efficiently, making it particularly advantageous for restoring large databases. Additionally, the use of .dump files results in significantly smaller backup sizes, saving storage space without compromising on data integrity.

Seamless Continuation on Interruption

One of the major benefits of pg_restore is its resilience in case of interruption. If the import process is interrupted for any reason, pg_restore can pick up from where it left off, ensuring that no data is lost and the restoration is completed without hassle.

Conclusion

In the realm of PostgreSQL database management, the combination of pg_dump and pg_restore offers a robust solution for secure backup and swift restoration. By leveraging these utilities, you can safeguard your data and restore it with unparalleled efficiency. The speed advantage and compact .dump file format make pg_restore the preferred choice for a seamless and streamlined database recovery process.

The Power of Rsync: Efficient File Synchronization for Linux

saeedeldeeb — Tue, 25 Jul 2023 00:07:08 +0000

Rsync is a powerful utility for file synchronization in Linux that allows you to efficiently copy and synchronize files between local and remote locations. In this article, we'll explore some of the most commonly used rsync commands and their practical applications.

Basic File Copying

Copy a File from Source to Destination:

To copy a single file from the source to the destination, use the following command:

   $ rsync source/photos.zip destination

Copy a Folder Recursively:

To copy a folder and its contents recursively, use the -r option:

   $ rsync -r source/ destination

Copy Files with Timestamp Preservation:

The -a option (archive mode) preserves file permissions, timestamps, and more during the copy operation:

   $ rsync -a source/ destination

Monitoring Progress

List Copying Progress:

For a more verbose output that lists the files being copied and the progress, use the -v (verbose) option:

   $ rsync -av source/ destination

Alternatively, use the --progress option for a human-readable progress indicator:

   $ rsync -a --progress source/ destination

Human-Readable Progress:

For a human-readable progress display, add the -h option:

   $ rsync -ah --progress source/ destination

Handling Interruptions

Partial Copies for Large Files:

When dealing with large files, use the --partial option to allow for partial copies. This enables you to resume interrupted transfers:

   $ rsync -ah --progress --partial source/ destination

Alternatively, the -P option is a shorthand for --partial --progress.

Advanced Synchronization

Syncing with Deletion:

To sync files and delete items in the destination that no longer exist in the source, add the --delete option:

   $ rsync -ahP --delete source/ destination

Remove Source Files after Successful Copy:

To automatically delete files from the source after a successful copy, use the --remove-source-files option:

   $ rsync -ahP --remove-source-files source/ destination

Note: This won't delete source folders, so an additional step is required, you can use $ find like -type d -empty -delete

Remote Synchronization

Synchronizing with a Remote Server:

To sync files from a local machine to a remote server, use the following syntax:

   $ rsync -ahP source root@your.ip:path/to/folder

Archiving Before Sync:

Archiving can be useful to preserve attributes and reduce the amount of data transferred. To archive a remote folder before syncing, use:
```
$ rsync -ahPz root@your.ip:path/to/folder source/
```
If the SSH port is non-default (e.g., 22), specify it using the -e option:
```
$ rsync -ahPze 'ssh -p 22' root@your.ip:path/to/folder source/
```

Rsync is a tool for efficiently managing file synchronization tasks on Linux systems. With its flexibility and numerous options, it empowers users to handle a wide range of data synchronization requirements with ease.

Connect One keyboard and mouse with multiple Laptops

saeedeldeeb — Sat, 22 Jul 2023 11:01:48 +0000

Barrier is a part-open source application that allows multiple computers to share a single keyboard and mouse set. This allows you to have multiple computers attached to separate monitors, all of which can be worked on with only one set of peripherals. Barrier works by running a server on the computer that the keyboard and mouse are connected to. This server then talks to clients that are installed on the other computers via SSH.
Barrier is working across different Operating Systems (MacOS, Linux, Windows) so you can download it very easily using .exe for windows and .dmg for mac and command line in linux.
Download from this link
And from command line ubuntu

sudo apt update
sudo apt -y install barrier

Now, I took the IP from server to client.

Maybe you would face this error

ssl certificate doesn't exist: /path/to/SSL/Barrier.pem
We need to install openssl within our server and client, so on windows:
From CMD winget install openssl or download it.
On linux:
From terminal sudo apt update sudo apt update openssl version

Then on both Operating Systems

cd  "path to your SSL"
mkdir -p Fingerprints
openssl req -x509 -nodes -days 365 -subj /CN=barrier -newkey rsa:4096 -keyout Barrier.pem -out Barrier.pem
openssl x509 -fingerprint -sha256 -noout -in Barrier.pem > Fingerprints/Local.txt
sed -e "s/.*=/v2:sha256:/" -i Fingerprints/Local.txt

Then restart your Barriers

Laravel 9, what's new?!

saeedeldeeb — Mon, 21 Feb 2022 13:07:00 +0000

Laravel and its other first-party packages follow Semantic Versioning. Major framework releases are released every year (~February), while minor and patch releases may be released as often as every week. Minor and patch releases should never contain breaking changes.

When referencing the Laravel framework or its components from your application or package, you should always use a version constraint such as ^9.0, since major releases of Laravel do include breaking changes. However, we strive to always ensure you may update to a new major release in one day or less.

From 8.x to 9.x important changes:

php is beginning transition to require function return type.
Belongs to many methods (firstOr..., UpdateOr...) now comparing against the related model not pivot.
They moved from swiftMailer to symfonyMailer.
lang directory have located to project root directory.
Use current_password validation rule instead of password

New features in 9.x:

Route controller group.
Anonymous migration class.
New helper functions.
Refreshed ignition error page.
Render blade string.
Forced scope bindings.
Laravel scout DB engine.
Full text indexing.
Enum attribute casting.
Simplified accessors and mutators.

we will discuss every point below:

Route controller group

If a group of routes all utilize the same controller, you may use the controller method to define the common controller for all of the routes within the group. Then, when defining the routes, you only need to provide the controller method that they invoke:

use App\Http\Controllers\OrderController;

Route::controller(OrderController::class)->group(function  () {
Route::get('/orders/{id}', 'show');
Route::post('/orders', 'store');
    });

They don't stop here but also made new console format when listing
project routes php artisan route:list

Anonymous migration class

Migration file now not class with name but anonymous one.

<?php
...
return  new  class  extends  Migration
{
    /**
    * Run the migrations.
    *
    * @return  void
    */
    public  function  up()
    {
    ...
    });
}

    /**
    * Reverse the migrations.
    *
    * @return  void
    */
    public  function  down()
    {
    ...
    }
};

New helper functions

str('__') /** equals to */ Str::of('__'); and it's good specially in blade as we don't need to use name space qualifier of Str class.
to_route('__'); /** equals to */ redirect()->route('__');

Refreshed ignition error page

Render blade string

Sometimes you may need to transform a raw Blade template string into valid HTML.

use Illuminate\Support\Facades\Blade;

return  Blade::render('Hello, @if(true) {$name} @endif', ['name'  =>  'Julian Bashir']);

Forced scope bindings

To bind models only belong to another model.

Route::get('/users/{user}/posts/{post:id}', function(User $user, Post $post){
...
})

we use post:id to see if user has this post , if not returns 404 but this can be dis-informative so explicitly:

Route::get('/users/{user}/posts/{post}', function(User $user, Post $post){
    ...
    })->scopeBindings();

Laravel scout DB engine

Scout package performs full text search, It used to using services but now for small projects we can use our DB engine.

Full text indexing

In migration class: $table->text('body')->fullText();
When searching: Post::whereFullText('body', '__')->get();

Enum attribute casting

Eloquent also allows you to cast your attribute values to PHP "backed" enums.

use App\Enums\ServerStatus;

/**
* The attributes that should be cast.
*
* @var  array
*/
protected  $casts  = [
'status'  =>  ServerStatus::class,
];

also Laravel allows you to type-hint an Enum on your route definition and Laravel will only invoke the route if that route segment corresponds to a valid Enum value. Otherwise, a 404 HTTP response will be returned automatically.

<?php

namespace App\Enums;

enum  Category:  string 
{
    case  Fruits  =  'fruits';    
    case  People  =  'people';    
}

use App\Enums\Category;
use Illuminate\Support\Facades\Route;

Route::get('/categories/{category}', function  (Category  $category) {
    return  $category->value;    
});

Simplified accessors and mutators

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Model;

class  User  extends  Model    
{    
    /**    
    * Interact with the user's first name.    
    *    
    * @param  string $value    
    * @return  \Illuminate\Database\Eloquent\Casts\Attribute    
    */    
    protected  function  firstName():  Attribute
    {    
        return  new  Attribute(    
        get: fn  ($value) => ucfirst($value),    
        set: fn  ($value) => strtolower($value),    
         );    
    }    
}

Laravel Sail

saeedeldeeb — Sun, 15 Aug 2021 14:51:20 +0000

As mentioned in sail docs:
Laravel Sail is a light-weight command-line interface for interacting with Laravel's default Docker development environment. Sail provides a great starting point for building a Laravel application using PHP, MySQL, and Redis without requiring prior Docker experience.

Steps to install Laravel Sail on your machine:

  1. Install Laravel using curl command from laravel builder:
       curl -s https://laravel.build/your-app-name | bash
       you can change your-app-name in the link.

 2. Move to the project directory:
       cd your-app-name

 3. To up your container 
       /vendor/bin/sail up -> this may take several minutes.

 4. Now you can see your App running on: 
       http://localhost.