Continuous data protection (CDP) szoftver, ingyenes. létezik?

Utoljára ilyet Oracle DBFS-sel (Database File System) láttam, amit FUSE tudott mountolni, alatta pedig természetesen ott volt az adatbázis, ami egy standby szerverre folyamatosan replikált. A redo logfileokban pedig ott volt az összes változás, amiből bármilyen PIT-re vissza lehet állni.

Nagyjából minden rendes adatbázishoz létezik CDP, filerendszerre csak ilyen nyakatekert megoldás van.

Pontosan mi a megoldando feladat? :)

https://wiki.r1soft.com/display/TP/Zmanda+Recovery+Manager+for+MySQL

Ezzel a fileok változás követésével az a baj, hogy mi számít változásnak? Ha a program 10000x ír 1 byteot a fájlba, az 10000 változtatást jelent? Vagy minden open-close ciklus egy változás? Esetleg percenként nézi meg, hogy volt-e azóta írás, viszont akkor könnyen lehet, hogy valamilyen köztes állapot kerül mentésre. DB-nél erre valók a tranzakciók, de filerendszeren nem nagyon van ilyen, de ha van is, milyen program használja?

A VSS alapvetően erre való, de az nem backup.

Egyéb oldalról a legtöbb backup megoldás tud sűrűn menteni. Arcserve esetén 15 percenként tudsz menteni és global dedup területre letárolni.

Leginkább egy megfelelő fs és egy lvm replika lehetne a tuti, de mindenképp nas vagy felhő. 

Mekkora a keret? 

DB esetén a motor tudatában van annak, hogy egy tranzakció lezárt, így tisztán tud konzisztens állapotot replikálni. Egy fájlrendszer esetében ez nem triviális, mert az oprendszer csak akkor lehet benne biztos, hogy a fájl konzisztens, amikor az lezárt. Ha elég neked lezáráskor menteni, akkor verziózott fájlrendszer (Windows fileshare tud ilyet) de akár egy rsync is elég. Ha blokkonként kéne, ahhoz végtelen storage kell, és igen lassú lesz, mert gyakorlatilag minden egyes blokk írása egyben egy snapshot is. Igazából tudományos érdekességen kívül sok értelmét nem látnám, mert a snapshot-ok többsége ugye az alkalmazás, de még a fájlrendszer szempontjából is inkonzisztens

A Bacula (ami egyébként egy kitűnű fájl szintű mentési megoldás a mai napig; mi sok helyen használjuk) rendelkezik ilyen képességgel. Egész valószínű, hogy kifejezetten a felhasználói app-ba épített ilyen képesség nélkül ennél tovább a többi mentési megoldás sem tud elmenni.

Bacula Continuous Data Protection

A leírások alapján nem teljesen egyértelmű, hogy csak a fizetős Enterprise vagy az ingyenes Community verzióban érhető el ez a plugin, de a dokumentáció alapján szerintem már a 13-as Community-ben elérhetővé vált (a páratlanok a Community, a párosak az Enterprise verziók), mert a 13-as doksijában már benne van, hogyan kell beállítani, használni.

Ha filesystem, akkor Venti? https://en.wikipedia.org/wiki/Venti_(software)

Kisebb problémáim vannak a kérdéssel. ;)

Ez az izé általában nem szoftver, hanem rendszer címszó alatt értelmezhető, ami a hardver+szoftver összehangolt működésével jellemezhető.

A legfontosabb az üzleti cél megfogalmazása, miszerint

• milyen időtartamú lehet a szolgáltatás kiesése
• milyen időtartam alatt keletkezett adatok veszhetnek el
• mennyi a helyreállítási idő

Létezett olyan rendszer, ami a 0-0-0 választ adhatta a fenti kérdésekre: Tandem gépeken a Guardian operációs rendszer. (a tandem ugye olyan bicigli, amin többen ülnek :-))

A kollégák nagyon utálták, mert a szövegszerkesző megnyitása után (--create file) a keletkezett fájlt többé nem lehetett eldobni. :--D

Ha szoftvert keresel, akkor a raid és replikáció kulcsszavak a barátaid. De a legfontosabb a fenti három kérdés megválaszolása! Nem utolsó sorban azt kell megválaszolni, hogy üzletileg mi az amit menteni kell.

beírtam neked chatgpt-be, viszont nem teszteltem

# Define the directory to monitor and the output directories for JSON and snapshots
$monitorDir = "C:\Path\To\Directory"
$backupDir = "C:\Path\To\Backup"
$jsonFile = $backupDir + "\changes.json"
$snapshotBaseDir = $backupDir + "\Snapshots"

# Create the snapshot directories if they do not exist
if (-not (Test-Path $snapshotBaseDir)) {
    New-Item -ItemType Directory -Path $snapshotBaseDir
}


# Function to save the list of changed files to the JSON file and copy files to snapshot directory
function Save-Changes {
    param (
        [string[]]$changedFiles,
        [string]$snapshotDir
    )

    if ($changedFiles.Count -gt 0) {
        $timestamp = Get-Date -Format "yyyy-MM-ddTHH-mm-ss"
        $snapshotDir = Join-Path $snapshotBaseDir $snapshotDir

        if (-not (Test-Path $snapshotDir)) {
            New-Item -ItemType Directory -Path $snapshotDir
        }

        $snapshot = [PSCustomObject]@{
            Timestamp = $timestamp
            ChangedFiles = $changedFiles
        }
        
        # Copy changed files to snapshot directory
        foreach ($file in $changedFiles) {
            $destinationPath = Join-Path $snapshotDir (Split-Path -Leaf $file)
            Copy-Item -Path $file -Destination $destinationPath -Recurse -Force
        }

        $existingData = @()
        if (Test-Path $jsonFile) {
            $existingData = Get-Content -Path $jsonFile | ConvertFrom-Json
            if ($null -eq $existingData) {
                $existingData = @()
            }
        }
        
        $existingData += $snapshot
        ConvertTo-Json $existingData | Set-Content -Path $jsonFile
        Write-Host "Changes detected and saved to $jsonFile and $snapshotDir"
    }
}

# Create initial snapshot if it does not exist
$initialSnapshotDir = Join-Path $snapshotBaseDir "0"
if (-not (Test-Path $initialSnapshotDir)) {
    Write-Host "Creating initial snapshot..."
    $initialFiles = Get-ChildItem -Path $monitorDir -Recurse | ForEach-Object { $_.FullName }
    Save-Changes -changedFiles $initialFiles -snapshotDir "0"
}

# Array to hold changed files
$changedFiles = @()

# Create the FileSystemWatcher
$watcher = New-Object System.IO.FileSystemWatcher
$watcher.Path = $monitorDir
$watcher.IncludeSubdirectories = $true
$watcher.EnableRaisingEvents = $true

# Event handlers for filesystem changes
$action = {
    param ($source, $eventArgs)
    $changedFiles += $eventArgs.FullPath
    $timestamp = Get-Date -Format "yyyy-MM-ddTHH-mm-ss"
    Save-Changes -changedFiles $changedFiles -snapshotDir $timestamp
    $changedFiles = @() # Reset the array after saving
}

$changedHandler = Register-ObjectEvent -InputObject $watcher -EventName Changed -SourceIdentifier FileChangedHandler -Action $action
$createdHandler = Register-ObjectEvent -InputObject $watcher -EventName Created -SourceIdentifier FileCreatedHandler -Action $action
$deletedHandler = Register-ObjectEvent -InputObject $watcher -EventName Deleted -SourceIdentifier FileDeletedHandler -Action $action
$renamedHandler = Register-ObjectEvent -InputObject $watcher -EventName Renamed -SourceIdentifier FileRenamedHandler -Action $action

try {
    # Keep the script running
    Write-Host "Monitoring directory: $monitorDir. Press Ctrl+C to stop."
    while ($true) {
        Wait-Event -Timeout 1
    }
} finally {
    # Clean up FileSystemWatcher and event handlers
    Unregister-Event -SourceIdentifier FileChangedHandler
    Unregister-Event -SourceIdentifier FileCreatedHandler
    Unregister-Event -SourceIdentifier FileDeletedHandler
    Unregister-Event -SourceIdentifier FileRenamedHandler
    $watcher.Dispose()
    Write-Host "FileSystemWatcher has been cleaned up."
}