Cara Swoole melaksanakan sandaran data berprestasi tinggi

Dalam beberapa tahun kebelakangan ini, sandaran data telah menjadi bahagian penting dalam pembinaan maklumat perusahaan. Apabila volum perniagaan dan volum data perusahaan meningkat, penyelesaian sandaran tradisional tidak lagi dapat memenuhi keperluan, jadi beberapa alat sandaran baharu telah muncul. Swoole ialah rangka kerja komunikasi rangkaian berprestasi tinggi berdasarkan bahasa PHP, yang digunakan terutamanya untuk melaksanakan aplikasi pelayan. Artikel ini akan memperkenalkan cara menggunakan Swoole untuk mencapai sandaran data berprestasi tinggi.

1. Sandarkan data

Pertama, kita perlu membuat sandaran data. Perisian pangkalan data seperti MySQL telah memberikan kami alat yang berkaitan Kami hanya perlu memanggil arahan yang sepadan untuk membuat sandaran data. Berikut ialah fungsi sandaran mudah:

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);
}

Fungsi ini menerima parameter berikut:

$db: nama pangkalan data yang perlu disandarkan

$pengguna: nama pengguna pangkalan data

$kata laluan; kata laluan pangkalan data;

Fungsi ini menyandarkan pangkalan data kepada fail, yang boleh menjadi fail skrip sql yang digunakan semasa memulihkan data. Sudah tentu, kaedah sandaran lain juga boleh digunakan, seperti menyalin fail pangkalan data, dsb.

2. Sandaran serentak

Jika data besar, proses sandaran mungkin mengambil sedikit masa. Menggunakan kaedah sandaran tradisional, anda hanya boleh membuat sandaran satu demi satu mengikut urutan sandaran yang ditentukan, dan tidak boleh melaksanakan berbilang tugas sandaran pada masa yang sama. Swoole menyediakan sokongan coroutine, yang boleh melaksanakan tugas sandaran tak segerak dan serentak.

Berikut ialah fungsi sandaran serentak yang dilaksanakan menggunakan 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;
}

Fungsi ini menerima dua parameter:

$maks: bilangan maksimum sandaran serentak

$pangkalan data: pangkalan data yang perlu disandarkan, termasuk setiap satu pangkalan data Maklumat sambungan.

Fungsi ini memulakan berbilang tugas sandaran serentak melalui coroutine. Mula-mula buat saluran dengan saiz $max untuk mengawal bilangan mata wang. Kemudian tugas sandaran dilaksanakan dalam gelung, setiap kali mengambil kedudukan yang tersedia dari saluran dan memulakan coroutine. Sandarkan pangkalan data yang ditentukan dalam coroutine, dan kemudian pulihkan kandungan fail sandaran ke pangkalan data sasaran. Akhirnya, keputusan disimpan dalam tatasusunan $results.

Oleh kerana coroutine adalah utas yang ringan dan boleh mengendalikan berbilang tugas serentak dalam satu utas, sandaran serentak yang cekap boleh dicapai.

3. Memampatkan fail sandaran

Apabila membuat sandaran data, untuk menjimatkan ruang storan, biasanya perlu memampatkan fail sandaran. Swoole menyediakan dua kaedah pemampatan, gzip dan zlib, yang boleh memampatkan fail sandaran dengan mudah.

Berikut ialah fungsi untuk memampatkan fail sandaran:

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;
    }
}

Fungsi ini menerima tiga parameter:

$nama fail: nama fail sandaran yang perlu dimampatkan;

$tahap: tahap mampatan, julat nilai ialah 1-9, lalai ialah 6;

$mod: mod mampatan, nilainya ialah SWOOLE_ZLIB atau SWOOLE_GZIP, lalai ialah SWOOLE_ZLIB.

Menggunakan fungsi ini, fail sandaran boleh dimampatkan ke dalam format gz atau zlib.

4. Mencapai sandaran berprestasi tinggi

Dengan menggabungkan tiga fungsi di atas, kita boleh mencapai sandaran data berprestasi tinggi. Berikut ialah contoh program:

$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);
}

Program ini mentakrifkan empat pangkalan data yang perlu disandarkan, dan menetapkan bilangan maksimum mata wang kepada 4. Mula-mula panggil fungsi concurrentBackup untuk menyandarkan data secara selari, dan kemudian mengeluarkan hasil sandaran dan masa pelaksanaan proses sandaran. Akhir sekali, mampatkan fail sandaran.

Gunakan Swoole untuk mencapai sandaran data berprestasi tinggi, yang boleh meningkatkan kecekapan sandaran berbanding kaedah sandaran tradisional. Walau bagaimanapun, apabila menggunakan Swoole untuk sandaran data, anda perlu memberi perhatian kepada penalaan parameter prestasi seperti saiz kolam benang untuk memanfaatkan Swoole.

Atas ialah kandungan terperinci Cara Swoole melaksanakan sandaran data berprestasi tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!