Comment Swoole met en œuvre une sauvegarde de données haute performance

Ces dernières années, la sauvegarde des données est devenue un élément essentiel de la construction des informations d'entreprise. À mesure que le volume d'activité et le volume de données des entreprises augmentent, les solutions de sauvegarde traditionnelles ne peuvent plus répondre aux besoins, c'est pourquoi de nouveaux outils de sauvegarde sont apparus. Swoole est un framework de communication réseau hautes performances basé sur le langage PHP, principalement utilisé pour implémenter des applications serveur. Cet article explique comment utiliser Swoole pour réaliser une sauvegarde de données hautes performances.

1. Sauvegarder les données

Tout d'abord, nous devons sauvegarder les données. Les logiciels de bases de données tels que MySQL nous ont fourni des outils pertinents. Il suffit d'appeler les commandes correspondantes pour sauvegarder les données. Voici une fonction de sauvegarde simple :

function backupDatabase($db, $user, $password, $host, $port, $output)
{
    $exec = "mysqldump --opt --skip-lock-tables --extended-insert --user={$user} --password={$password} --host={$host} --port={$port} {$db}";
    if($output)
    {
        $exec .= " > {$output}";
    }
    exec($exec);
}

Cette fonction reçoit les paramètres suivants :

$db : le nom de la base de données à sauvegarder #🎜🎜 ; #

$user : Nom d'utilisateur de la base de données ;

$password : Mot de passe de la base de données

$host : Nom d'hôte de la base de données ; port : numéro de port de la base de données ; # 🎜🎜#

$output : chemin du fichier de sauvegarde, peut être nul.

Cette fonction sauvegarde la base de données dans un fichier, qui peut être un fichier de script SQL utilisé lors de la restauration des données. Bien entendu, d'autres méthodes de sauvegarde peuvent également être utilisées, comme la copie de fichiers de base de données, etc.

2. Sauvegarde simultanée

Si les données sont volumineuses, le processus de sauvegarde peut prendre un certain temps. En utilisant la méthode de sauvegarde traditionnelle, vous ne pouvez sauvegarder qu'une par une selon l'ordre de sauvegarde spécifié et vous ne pouvez pas effectuer plusieurs tâches de sauvegarde en même temps. Swoole fournit un support coroutine, qui peut implémenter des tâches de sauvegarde asynchrones et simultanées.

Ce qui suit est une fonction de sauvegarde simultanée implémentée à l'aide de Swoole :

function concurrentBackup($max, $databases)
{
    $num = count($databases);
    $max = min($max, $num);
    $chan = new chan($max);

    for($i = 0; $i < $max; $i++)
    {
        $chan->push($i);
    }

    $results = [];
    $i = 0;
    $executor = new SwooleCoroutineMysql();

    while($i < $num)
    {
        if($result = $chan->pop())
        {
            $database = $databases[$i];
            go(function() use($database, $executor, $chan, &$results) {
                $executor->connect([
                    'host' => $database['host'],
                    'user' => $database['user'],
                    'password' => $database['password'],
                    'database' => $database['schema']
                ]);

                $filename = "/tmp/{$database['schema']}.sql";
                backupDatabase($database['schema'], $database['user'], $database['password'], $database['host'], $database['port'], $filename);

                $executor->query('DROP TABLE IF EXISTS test');

                $result = $executor->query("source {$filename}");
                if($result === false) {
                    $results[$database['schema']] = 'error';
                } else {
                    $results[$database['schema']] = 'ok';
                }

                $executor->close();

                $chan->push(1);
            });

            $i++;
            if($i == $num) break;
        }
    }

    while(count($results) < $num)
    {
        Co::sleep(0.01);
    }

    return $results;
}

Cette fonction reçoit deux paramètres :

$max : le nombre de sauvegardes simultanées Valeur maximale ;

$bases de données : bases de données qui doivent être sauvegardées, y compris les informations de connexion pour chaque base de données.

Cette fonction démarre plusieurs tâches de sauvegarde simultanées via des coroutines. Créez d’abord un canal d’une taille de $max pour contrôler le nombre de simultanéités. Ensuite, la tâche de sauvegarde est exécutée en boucle, prenant à chaque fois une position disponible sur le canal et démarrant une coroutine. Sauvegardez la base de données spécifiée dans la coroutine, puis restaurez le contenu du fichier de sauvegarde dans la base de données cible. Enfin, les résultats sont stockés dans le tableau $results.

Étant donné que les coroutines sont des threads légers qui peuvent gérer plusieurs tâches simultanément dans un seul thread, une sauvegarde simultanée efficace peut être réalisée.

3. Compresser les fichiers de sauvegarde

Lors de la sauvegarde de données, afin d'économiser de l'espace de stockage, il est généralement nécessaire de compresser les fichiers de sauvegarde. Swoole propose deux méthodes de compression, gzip et zlib, qui permettent de compresser facilement les fichiers de sauvegarde.

Ce qui suit est une fonction pour compresser les fichiers de sauvegarde :

function compressBackupFile($filename, $level = 6, $mode = SWOOLE_ZLIB)
{
    $output = $filename . '.gz';
    $ouputFile = gzopen($output, 'wb' . $level);
    $inFile = fopen($filename, 'rb');

    if ($ouputFile && $inFile) {
        if($mode == SWOOLE_ZLIB) {
            $z = new SwooleZlib(SW_ZLIB_DEFLATE, $level, SW_ZLIB_ENCODING_GZIP);
            while(!feof($inFile)) {
                $data = fread($inFile, 1024 * 4);
                if(!$data) break;
                if($z->deflate($data)) {
                    gzwrite($ouputFile, $z->output);
                }
            }
            $z->flush(true);
            gzwrite($ouputFile, $z->output);
        } else {
            while(!feof($inFile)) {
                $data = fread($inFile, 1024 * 4);
                if(!$data) break;
                gzwrite($ouputFile, $data);
            }
        }
        fclose($inFile);
        gzclose($ouputFile);
        unlink($filename);
        return true;
    } else {
        return false;
    }
}

Cette fonction reçoit trois paramètres :

$filename : le nom du fichier de sauvegarde qui doit être compressé ;

$level : niveau de compression, plage de valeurs 1-9, la valeur par défaut est 6

$mode : méthode de compression, la valeur est SWOOLE_ZLIB ou SWOOLE_GZIP, la valeur par défaut est SWOOLE_ZLIB .

Grâce à cette fonction, le fichier de sauvegarde peut être compressé au format gz ou zlib.

Quatrièmement, réaliser une sauvegarde de données haute performance

En combinant les trois fonctions ci-dessus, nous pouvons réaliser une sauvegarde de données haute performance. Voici un exemple de programme :

$databases = [
    [
        'host' => '127.0.0.1',
        'port' => 3306,
        'user' => 'root',
        'password' => '',
        'schema' => 'db1',
    ],
    [
        'host' => '127.0.0.1',
        'port' => 3306,
        'user' => 'root',
        'password' => '',
        'schema' => 'db2',
    ],
    [
        'host' => '127.0.0.1',
        'port' => 3306,
        'user' => 'root',
        'password' => '',
        'schema' => 'db3',
    ],
    [
        'host' => '127.0.0.1',
        'port' => 3306,
        'user' => 'root',
        'password' => '',
        'schema' => 'db4',
    ],
];

$max = 4;

$s1 = microtime(true);
$results = concurrentBackup($max, $databases);

foreach($results as $schema => $result)
{
    echo "{$schema} backup: {$result}
";
}

$s2 = microtime(true);
echo "time consumed: " . round($s2 - $s1, 3) . "s
";

foreach($databases as $database)
{
    $filename = "/tmp/{$database['schema']}.sql.gz";
    compressBackupFile($filename, 6, SWOOLE_GZIP);
}

Ce programme définit quatre bases de données qui doivent être sauvegardées et définit le nombre maximum de simultanéités à 4. Appelez d'abord la fonction concurrentBackup pour sauvegarder les données en parallèle, puis affichez les résultats de la sauvegarde et le temps d'exécution du processus de sauvegarde. Enfin, compressez le fichier de sauvegarde.

L'utilisation de Swoole pour réaliser une sauvegarde de données hautes performances peut considérablement améliorer l'efficacité de la sauvegarde par rapport aux méthodes de sauvegarde traditionnelles. Cependant, lorsque vous utilisez Swoole pour la sauvegarde de données, vous devez faire attention au réglage des paramètres de performances tels que la taille du pool de threads pour tirer parti de Swoole.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!