Object Replication

Lab Objective

In this hands-on lab, you will learn how to:

• Configure Azure Blob Storage object replication between storage accounts
• Set up replication policies with filters and rules
• Monitor replication status and troubleshoot failures
• Implement cross-region object replication for disaster recovery
• Handle replication conflicts and version management
• Optimize replication performance and costs
• Test failback scenarios after disaster recovery

Scenario: Your organization needs to implement automatic replication of critical blob data across multiple regions for disaster recovery and data distribution. You’ll configure object replication policies and test various scenarios including conflict resolution.

---

Pre-Provisioned Environment

The following Azure resources have been pre-deployed in your environment:

Resource Overview

Resource Type	Resource Name	Configuration	Purpose
Resource Group	ObjectReplication-Lab-RG	Contains all lab resources	Logical container
Source Storage	srcstore[unique]	East US, LRS, Blob versioning	Primary data source
Destination Storage	dststore[unique]	West US, LRS, Blob versioning	Replication target
Backup Storage	backupstore[unique]	Central US, GRS	Additional backup
Test VM	ReplicationVM	Windows Server 2019	Data management and testing
Blob Containers	Various	Different access levels	Test data organization

Storage Account Configuration

Account	Region	Redundancy	Versioning	Change Feed	Purpose
srcstore[unique]	East US	LRS	Enabled	Enabled	Source for replication
dststore[unique]	West US	LRS	Enabled	Enabled	Primary destination
backupstore[unique]	Central US	GRS	Enabled	Enabled	Secondary backup

Container Structure

Source Storage (srcstore[unique])
├── documents/          (Private access)
│   ├── policies/
│   ├── reports/
│   └── templates/
├── media/              (Private access)
│   ├── images/
│   ├── videos/
│   └── audio/
└── archive/            (Private access)
    ├── 2023/
    ├── 2024/
    └── current/

Destination Storage (dststore[unique])
├── documents/          (Replicated)
├── media/              (Replicated)
└── archive/            (Replicated)

VM Details

VM	Private IP	Operating System	Purpose
ReplicationVM	10.0.1.4	Windows Server 2019	Upload data and monitor replication

---

Lab Exercises

Part 1: Enable Object Replication Prerequisites

Step 1: Verify Storage Account Configuration

1. Navigate to ObjectReplication-Lab-RG resource group
2. Check source storage account (srcstore[unique]):

Verify versioning:

• Go to Data protection
• Confirm: Blob versioning = “Enabled”
• Confirm: Change feed = “Enabled”

Check containers:

• Go to Containers
• Verify containers: documents, media, archive
• Note: All should have private access level

Step 2: Configure Destination Storage

1. Navigate to dststore[unique] storage account
2. Enable required features:

Enable versioning:

• Go to Data protection
• Enable “Blob versioning”
• Enable “Change feed”
• Click Save

Step 3: Connect to Test VM

1. Navigate to ReplicationVM
2. Click Connect → RDP
3. Use credentials:
   • Username: azureuser
   • Password: LabPassword123!

Step 4: Install Azure PowerShell and Login

From ReplicationVM PowerShell (as Administrator):

# Install Azure PowerShell module
Install-Module -Name Az -Force -AllowClobber
Import-Module Az

# Connect to Azure
Connect-AzAccount

# Set context
$resourceGroup = "ObjectReplication-Lab-RG"
$sourceAccount = "srcstore[unique]"
$destAccount = "dststore[unique]"
$backupAccount = "backupstore[unique]"

---

Part 2: Create Test Data

Step 1: Generate Sample Files

# Create local test data directory
$testDataPath = "C:\TestData"
New-Item -ItemType Directory -Path $testDataPath -Force

# Create documents
$documentsPath = "$testDataPath\documents"
New-Item -ItemType Directory -Path $documentsPath -Force

# Policy documents
@("security-policy.pdf", "hr-policy.docx", "it-policy.txt") | ForEach-Object {
    $content = "Policy document: $_ `nCreated: $(Get-Date)`nContent: " + ("Policy content line`n" * 100)
    $content | Out-File -FilePath "$documentsPath\$_" -Encoding UTF8
}

# Reports
$reportsPath = "$documentsPath\reports"
New-Item -ItemType Directory -Path $reportsPath -Force

@("monthly-report.xlsx", "quarterly-summary.pdf", "annual-review.docx") | ForEach-Object {
    $content = "Report: $_ `nGenerated: $(Get-Date)`nData: " + ("Report data line`n" * 200)
    $content | Out-File -FilePath "$reportsPath\$_" -Encoding UTF8
}

# Media files (simulate with text content)
$mediaPath = "$testDataPath\media"
New-Item -ItemType Directory -Path $mediaPath -Force

# Create "image" files
@("logo.png", "banner.jpg", "profile.gif") | ForEach-Object {
    $bytes = New-Object byte[] (1MB)
    (New-Object Random).NextBytes($bytes)
    [System.IO.File]::WriteAllBytes("$mediaPath\$_", $bytes)
}

# Archive data
$archivePath = "$testDataPath\archive"
New-Item -ItemType Directory -Path $archivePath -Force

# Create archive files by date
$currentYear = Get-Date -Format "yyyy"
$archiveYearPath = "$archivePath\$currentYear"
New-Item -ItemType Directory -Path $archiveYearPath -Force

1..5 | ForEach-Object {
    $content = "Archive data file $_`nArchived: $(Get-Date)`nData: " + ("Archived content line`n" * 50)
    $content | Out-File -FilePath "$archiveYearPath\archive-data-$_.txt" -Encoding UTF8
}

Write-Host "Test data created successfully"
Get-ChildItem $testDataPath -Recurse | Select-Object FullName, Length

Step 2: Upload Data to Source Storage

# Get source storage context
$sourceStorage = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount
$sourceCtx = $sourceStorage.Context

# Upload documents
Write-Host "Uploading documents..."
$documentsContainer = "documents"

# Upload policy files
Get-ChildItem "$documentsPath\*.pdf", "$documentsPath\*.docx", "$documentsPath\*.txt" | ForEach-Object {
    Set-AzStorageBlobContent -File $_.FullName -Container $documentsContainer -Blob "policies/$($_.Name)" -Context $sourceCtx -Force
    Write-Host "Uploaded: policies/$($_.Name)"
}

# Upload reports
Get-ChildItem "$reportsPath\*" | ForEach-Object {
    Set-AzStorageBlobContent -File $_.FullName -Container $documentsContainer -Blob "reports/$($_.Name)" -Context $sourceCtx -Force
    Write-Host "Uploaded: reports/$($_.Name)"
}

# Upload media files
Write-Host "Uploading media files..."
$mediaContainer = "media"

Get-ChildItem "$mediaPath\*" | ForEach-Object {
    $blobName = "images/$($_.Name)"
    Set-AzStorageBlobContent -File $_.FullName -Container $mediaContainer -Blob $blobName -Context $sourceCtx -Force
    Write-Host "Uploaded: $blobName"
}

# Upload archive data
Write-Host "Uploading archive data..."
$archiveContainer = "archive"

Get-ChildItem "$archiveYearPath\*" | ForEach-Object {
    $blobName = "$currentYear/$($_.Name)"
    Set-AzStorageBlobContent -File $_.FullName -Container $archiveContainer -Blob $blobName -Context $sourceCtx -Force
    Write-Host "Uploaded: $blobName"
}

Write-Host "All test data uploaded successfully"

---

Part 3: Configure Object Replication Policy

Step 1: Create Replication Policy via Azure Portal

1. Navigate to srcstore[unique] (source storage account)
2. Go to Data management → Object replication
3. Click “Set up replication rules”

Configure basic settings:

• Destination account: Select dststore[unique]
• Source container: documents
• Destination container: documents

Step 2: Configure Advanced Replication Rules

Rule 1: Documents Policy Replication

• Rule name: ReplicateDocuments
• Source container: documents
• Destination container: documents
• Prefix filter: policies/
• Minimum creation time: Leave empty (replicate all)

Rule 2: Reports Replication

• Rule name: ReplicateReports
• Source container: documents
• Destination container: documents
• Prefix filter: reports/

Rule 3: Media Replication

• Rule name: ReplicateMedia
• Source container: media
• Destination container: media
• Prefix filter: Leave empty (replicate all)

Step 3: Configure via PowerShell (Alternative Method)

# Create replication policy using PowerShell
$sourceStorage = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount
$destStorage = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $destAccount

# Create replication rules
$rule1 = New-AzStorageObjectReplicationPolicyRule -RuleId "Rule1" -SourceContainer "documents" -DestinationContainer "documents" -PrefixMatch "policies/"
$rule2 = New-AzStorageObjectReplicationPolicyRule -RuleId "Rule2" -SourceContainer "documents" -DestinationContainer "documents" -PrefixMatch "reports/"
$rule3 = New-AzStorageObjectReplicationPolicyRule -RuleId "Rule3" -SourceContainer "media" -DestinationContainer "media"

# Create policy on source account
$policy = Set-AzStorageObjectReplicationPolicy -ResourceGroupName $resourceGroup -StorageAccountName $sourceAccount -PolicyId "Policy1" -SourceAccount $sourceAccount -DestinationAccount $destAccount -Rule $rule1,$rule2,$rule3

Write-Host "Replication policy created: $($policy.PolicyId)"
Write-Host "Rules configured: $($policy.Rules.Count)"

Step 4: Monitor Policy Creation

# Check replication policy status
$replicationPolicies = Get-AzStorageObjectReplicationPolicy -ResourceGroupName $resourceGroup -StorageAccountName $sourceAccount

$replicationPolicies | ForEach-Object {
    Write-Host "Policy ID: $($_.PolicyId)"
    Write-Host "Source Account: $($_.SourceAccount)"
    Write-Host "Destination Account: $($_.DestinationAccount)"
    Write-Host "Rules:"
    $_.Rules | ForEach-Object {
        Write-Host "  - Rule ID: $($_.RuleId)"
        Write-Host "    Source Container: $($_.SourceContainer)"
        Write-Host "    Destination Container: $($_.DestinationContainer)"
        Write-Host "    Prefix Match: $($_.PrefixMatch)"
    }
    Write-Host "---"
}

---

Part 4: Monitor and Verify Replication

Step 1: Check Replication Status

# Monitor replication progress
function Check-ReplicationStatus {
    param($SourceAccount, $DestAccount, $ContainerName)

    $sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $SourceAccount).Context
    $destCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $DestAccount).Context

    # Get source blobs
    $sourceBlobs = Get-AzStorageBlob -Container $ContainerName -Context $sourceCtx
    Write-Host "Source blobs in $ContainerName`: $($sourceBlobs.Count)"

    # Get destination blobs
    try {
        $destBlobs = Get-AzStorageBlob -Container $ContainerName -Context $destCtx
        Write-Host "Destination blobs in $ContainerName`: $($destBlobs.Count)"

        # Compare blob metadata for replication status
        $sourceBlobs | ForEach-Object {
            $sourceBlobName = $_.Name
            $destBlob = $destBlobs | Where-Object { $_.Name -eq $sourceBlobName }

            if ($destBlob) {
                # Check replication metadata
                $blobProperties = Get-AzStorageBlob -Container $ContainerName -Blob $sourceBlobName -Context $sourceCtx
                $replicationStatus = $blobProperties.BlobProperties.ObjectReplicationSourceProperties

                if ($replicationStatus) {
                    Write-Host "  $sourceBlobName`: Replicated"
                } else {
                    Write-Host "  $sourceBlobName`: Replication status unknown"
                }
            } else {
                Write-Host "  $sourceBlobName`: NOT replicated"
            }
        }
    } catch {
        Write-Host "Destination container $ContainerName does not exist or is not accessible"
    }

    Write-Host "---"
}

# Check replication for all containers
Write-Host "Checking replication status..."
Check-ReplicationStatus -SourceAccount $sourceAccount -DestAccount $destAccount -ContainerName "documents"
Check-ReplicationStatus -SourceAccount $sourceAccount -DestAccount $destAccount -ContainerName "media"

Step 2: Verify Replication Metadata

# Check detailed replication metadata
$sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context

# Get a specific blob and check its replication properties
$testBlob = Get-AzStorageBlob -Container "documents" -Blob "policies/security-policy.pdf" -Context $sourceCtx

Write-Host "Blob replication properties:"
Write-Host "Name: $($testBlob.Name)"
Write-Host "Last Modified: $($testBlob.LastModified)"
Write-Host "ETag: $($testBlob.ETag)"

# Check for replication metadata
$blobProperties = $testBlob.BlobProperties
if ($blobProperties.ObjectReplicationSourceProperties) {
    Write-Host "Object replication properties found:"
    $blobProperties.ObjectReplicationSourceProperties | ForEach-Object {
        Write-Host "  Policy ID: $($_.PolicyId)"
        Write-Host "  Rule ID: $($_.RuleId)"
        Write-Host "  Status: $($_.ReplicationStatus)"
    }
} else {
    Write-Host "No object replication properties found"
}

Step 3: Test Real-time Replication

# Upload a new file and monitor replication
$newFileName = "test-replication-$(Get-Date -Format 'yyyyMMdd-HHmmss').txt"
$newFileContent = "Test file for replication monitoring`nCreated: $(Get-Date)`nContent: This file tests real-time replication"
$newFilePath = "C:\temp\$newFileName"

# Create temporary directory and file
New-Item -ItemType Directory -Path "C:\temp" -Force
$newFileContent | Out-File -FilePath $newFilePath -Encoding UTF8

# Upload to source
Write-Host "Uploading new test file: $newFileName"
Set-AzStorageBlobContent -File $newFilePath -Container "documents" -Blob "reports/$newFileName" -Context $sourceCtx -Force

# Monitor replication over time
1..10 | ForEach-Object {
    Start-Sleep -Seconds 30
    Write-Host "Check $_ ($(Get-Date)):"

    $destCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $destAccount).Context
    try {
        $replicatedBlob = Get-AzStorageBlob -Container "documents" -Blob "reports/$newFileName" -Context $destCtx -ErrorAction SilentlyContinue
        if ($replicatedBlob) {
            Write-Host "  File replicated successfully!"
            Write-Host "  Destination LastModified: $($replicatedBlob.LastModified)"
            break
        } else {
            Write-Host "  File not yet replicated..."
        }
    } catch {
        Write-Host "  File not yet replicated (container may not exist)..."
    }
}

# Clean up
Remove-Item $newFilePath -Force

---

Part 5: Handle Replication Conflicts and Versioning

Step 1: Create Version Conflicts

# Upload same file to both source and destination with different content
$conflictFileName = "conflict-test.txt"
$sourceContent = "Source version - Created at $(Get-Date) from source account"
$destContent = "Destination version - Created at $(Get-Date) from destination account"

# Create local files
$sourceFilePath = "C:\temp\source-$conflictFileName"
$destFilePath = "C:\temp\dest-$conflictFileName"

$sourceContent | Out-File -FilePath $sourceFilePath -Encoding UTF8
$destContent | Out-File -FilePath $destFilePath -Encoding UTF8

# Upload to source first
$sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context
Set-AzStorageBlobContent -File $sourceFilePath -Container "documents" -Blob "reports/$conflictFileName" -Context $sourceCtx -Force
Write-Host "Uploaded to source account"

# Wait a moment, then upload different content to destination
Start-Sleep -Seconds 5
$destCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $destAccount).Context
Set-AzStorageBlobContent -File $destFilePath -Container "documents" -Blob "reports/$conflictFileName" -Context $destCtx -Force
Write-Host "Uploaded to destination account"

# Wait for replication to process the conflict
Start-Sleep -Seconds 30
Write-Host "Checking conflict resolution..."

Step 2: Examine Version History

# Check versions in source account
Write-Host "Source account versions:"
$sourceVersions = Get-AzStorageBlob -Container "documents" -Blob "reports/$conflictFileName" -Context $sourceCtx -IncludeVersion
$sourceVersions | ForEach-Object {
    Write-Host "  Version: $($_.VersionId), LastModified: $($_.LastModified), IsCurrentVersion: $($_.IsLatestVersion)"
}

# Check versions in destination account
Write-Host "Destination account versions:"
$destVersions = Get-AzStorageBlob -Container "documents" -Blob "reports/$conflictFileName" -Context $destCtx -IncludeVersion
$destVersions | ForEach-Object {
    Write-Host "  Version: $($_.VersionId), LastModified: $($_.LastModified), IsCurrentVersion: $($_.IsLatestVersion)"
}

# Download and compare current versions
$sourceCurrentContent = Get-AzStorageBlobContent -Container "documents" -Blob "reports/$conflictFileName" -Context $sourceCtx -Destination "C:\temp\source-current.txt" -Force
$destCurrentContent = Get-AzStorageBlobContent -Container "documents" -Blob "reports/$conflictFileName" -Context $destCtx -Destination "C:\temp\dest-current.txt" -Force

Write-Host "Source current content:"
Get-Content "C:\temp\source-current.txt"
Write-Host "Destination current content:"
Get-Content "C:\temp\dest-current.txt"

Step 3: Resolve Conflicts Manually

# Manual conflict resolution - promote specific version
$sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context

# Get all versions of the conflicted file
$allVersions = Get-AzStorageBlob -Container "documents" -Blob "reports/$conflictFileName" -Context $sourceCtx -IncludeVersion | Sort-Object LastModified

Write-Host "Available versions:"
$allVersions | ForEach-Object {
    Write-Host "  Version $($_.VersionId): $($_.LastModified)"
}

# Choose the latest version and promote it
$latestVersion = $allVersions | Select-Object -Last 1
Write-Host "Promoting version: $($latestVersion.VersionId)"

# Copy the chosen version to become the current version
Copy-AzStorageBlob -SrcContainer "documents" -SrcBlob "reports/$conflictFileName" -SrcContext $sourceCtx -DestContainer "documents" -DestBlob "reports/$conflictFileName" -DestContext $sourceCtx -SrcBlobVersion $latestVersion.VersionId -Force

Write-Host "Version promoted successfully"

---

Part 6: Implement Multi-Destination Replication

Step 1: Add Third Destination

# Configure replication to backup storage account
$backupStorage = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $backupAccount
$backupCtx = $backupStorage.Context

# Create containers in backup storage
@("documents", "media", "archive") | ForEach-Object {
    New-AzStorageContainer -Name $_ -Context $backupCtx -Permission Off -ErrorAction SilentlyContinue
    Write-Host "Created container: $_"
}

# Create additional replication policy for backup
$backupRule1 = New-AzStorageObjectReplicationPolicyRule -RuleId "BackupRule1" -SourceContainer "documents" -DestinationContainer "documents" -PrefixMatch "policies/"
$backupRule2 = New-AzStorageObjectReplicationPolicyRule -RuleId "BackupRule2" -SourceContainer "archive" -DestinationContainer "archive"

$backupPolicy = Set-AzStorageObjectReplicationPolicy -ResourceGroupName $resourceGroup -StorageAccountName $sourceAccount -PolicyId "BackupPolicy" -SourceAccount $sourceAccount -DestinationAccount $backupAccount -Rule $backupRule1,$backupRule2

Write-Host "Backup replication policy created: $($backupPolicy.PolicyId)"

Step 2: Monitor Multi-Destination Replication

# Function to check replication across all destinations
function Check-MultiDestinationReplication {
    param($BlobName, $ContainerName)

    $sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context
    $destCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $destAccount).Context
    $backupCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $backupAccount).Context

    Write-Host "Checking replication for: $ContainerName/$BlobName"

    # Check source
    try {
        $sourceBlob = Get-AzStorageBlob -Container $ContainerName -Blob $BlobName -Context $sourceCtx
        Write-Host "  Source: EXISTS (Modified: $($sourceBlob.LastModified))"
    } catch {
        Write-Host "  Source: NOT FOUND"
        return
    }

    # Check primary destination
    try {
        $destBlob = Get-AzStorageBlob -Container $ContainerName -Blob $BlobName -Context $destCtx
        Write-Host "  Primary Destination: EXISTS (Modified: $($destBlob.LastModified))"
    } catch {
        Write-Host "  Primary Destination: NOT FOUND"
    }

    # Check backup destination
    try {
        $backupBlob = Get-AzStorageBlob -Container $ContainerName -Blob $BlobName -Context $backupCtx
        Write-Host "  Backup Destination: EXISTS (Modified: $($backupBlob.LastModified))"
    } catch {
        Write-Host "  Backup Destination: NOT FOUND"
    }

    Write-Host "---"
}

# Test multi-destination replication
Check-MultiDestinationReplication -BlobName "policies/security-policy.pdf" -ContainerName "documents"
Check-MultiDestinationReplication -BlobName "2024/archive-data-1.txt" -ContainerName "archive"

---

Part 7: Performance Optimization and Monitoring

Step 1: Monitor Replication Performance

# Create performance monitoring script
function Monitor-ReplicationPerformance {
    $policies = Get-AzStorageObjectReplicationPolicy -ResourceGroupName $resourceGroup -StorageAccountName $sourceAccount

    foreach ($policy in $policies) {
        Write-Host "Policy: $($policy.PolicyId) -> $($policy.DestinationAccount)"

        foreach ($rule in $policy.Rules) {
            Write-Host "  Rule: $($rule.RuleId)"
            Write-Host "    Source: $($rule.SourceContainer)"
            Write-Host "    Destination: $($rule.DestinationContainer)"
            Write-Host "    Prefix: $($rule.PrefixMatch)"

            # Get source container stats
            $sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context
            $sourceBlobs = Get-AzStorageBlob -Container $rule.SourceContainer -Context $sourceCtx

            if ($rule.PrefixMatch) {
                $filteredBlobs = $sourceBlobs | Where-Object { $_.Name.StartsWith($rule.PrefixMatch) }
            } else {
                $filteredBlobs = $sourceBlobs
            }

            Write-Host "    Source objects: $($filteredBlobs.Count)"

            # Calculate total size
            $totalSize = ($filteredBlobs | Measure-Object -Property Length -Sum).Sum
            Write-Host "    Total size: $([math]::Round($totalSize / 1MB, 2)) MB"
        }
        Write-Host "---"
    }
}

Monitor-ReplicationPerformance

Step 2: Optimize Replication Rules

# Create optimized replication rules based on file patterns
function Optimize-ReplicationRules {
    # Analyze source data patterns
    $sourceCtx = (Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount).Context

    @("documents", "media", "archive") | ForEach-Object {
        $containerName = $_
        Write-Host "Analyzing container: $containerName"

        $blobs = Get-AzStorageBlob -Container $containerName -Context $sourceCtx

        # Group by file extension
        $extensions = $blobs | Group-Object { [System.IO.Path]::GetExtension($_.Name) }

        Write-Host "  File types:"
        $extensions | ForEach-Object {
            $ext = if ($_.Name) { $_.Name } else { "No extension" }
            $totalSize = ($_.Group | Measure-Object -Property Length -Sum).Sum
            Write-Host "    $ext`: $($_.Count) files, $([math]::Round($totalSize / 1MB, 2)) MB"
        }

        # Group by directory prefix
        $prefixes = $blobs | Group-Object {
            $path = $_.Name
            if ($path.Contains("/")) {
                $path.Substring(0, $path.IndexOf("/"))
            } else {
                "root"
            }
        }

        Write-Host "  Directory prefixes:"
        $prefixes | ForEach-Object {
            $totalSize = ($_.Group | Measure-Object -Property Length -Sum).Sum
            Write-Host "    $($_.Name): $($_.Count) files, $([math]::Round($totalSize / 1MB, 2)) MB"
        }

        Write-Host "---"
    }
}

Optimize-ReplicationRules

Step 3: Set up Replication Monitoring Alerts

# Create metrics and alerts for replication monitoring
$sourceStorage = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $sourceAccount

Write-Host "Storage account metrics:"
Write-Host "  Account: $($sourceStorage.StorageAccountName)"
Write-Host "  Resource ID: $($sourceStorage.Id)"
Write-Host "  Location: $($sourceStorage.Location)"

# Note: In production, you would create Azure Monitor alerts here
Write-Host "Recommended alerts to create:"
Write-Host "  - Object replication failures"
Write-Host "  - Replication lag exceeding threshold"
Write-Host "  - Storage account availability issues"
Write-Host "  - Blob version conflicts"

---

Troubleshooting Guide

Common Object Replication Issues

Issue	Symptoms	Possible Cause	Solution
Replication not starting	No objects appear in destination	Missing prerequisites	Enable versioning and change feed
Partial replication	Some objects missing	Filter rules too restrictive	Review prefix match settings
Slow replication	Long delays between source and destination	Network or service issues	Check service health and retry
Version conflicts	Unexpected version behavior	Concurrent writes to same blob	Implement proper conflict resolution
Policy creation fails	Error creating replication policy	Permission or configuration issues	Verify account settings and permissions

Replication Prerequisites Checklist

Requirement	Source Account	Destination Account	Status
Blob versioning	✅ Enabled	✅ Enabled	Required
Change feed	✅ Enabled	✅ Enabled	Required
Access tier	Hot or Cool	Hot or Cool	Required
Account type	GPv2 or BlockBlobStorage	GPv2 or BlockBlobStorage	Required
Region	Any supported	Different from source	Recommended

Performance Optimization Tips

Scenario	Recommendation	Benefit
Large files	Use prefix filters to prioritize	Faster critical data replication
Many small files	Group by common prefixes	Reduce management overhead
Mixed workloads	Separate policies by data type	Optimize for different SLAs
Cross-region	Choose nearby regions	Reduce latency and costs
Archive data	Use separate policy with longer intervals	Cost optimization

---

Additional Experiments

Try these optional exercises to deepen your understanding:

• Failback Testing: Configure reverse replication after disaster recovery
• Cost Analysis: Compare replication costs vs. geo-redundant storage
• Lifecycle Integration: Combine with lifecycle management policies
• Custom Automation: Create PowerShell scripts for automated failover
• Monitoring Dashboard: Build Azure Monitor dashboards for replication health

---

Key Takeaways

After completing this lab, you should understand:

• Object replication provides asynchronous copying of block blobs between storage accounts
• Prerequisites include blob versioning and change feed on both accounts
• Replication policies define rules with filters and prefixes for selective replication
• Version conflicts can occur and need proper resolution strategies
• Multi-destination replication enables complex disaster recovery scenarios
• Performance optimization requires understanding of data patterns and access needs
• Monitoring and alerting are essential for production replication scenarios

---

Replication Decision Matrix

Use Cases and Recommendations

Use Case	Recommended Setup	Policy Configuration	Monitoring Focus
Disaster Recovery	Cross-region with RA-GRS	Replicate all critical data	Replication lag, failures
Data Distribution	Multi-region with filters	Replicate by geography	Bandwidth usage, costs
Backup Strategy	Same region, different account	Archive data only	Storage costs, retention
Development/Test	Single region, filtered data	Test data subset	Development lifecycle
Compliance	Multi-region with versioning	Audit trail preservation	Version conflicts, history

Performance Considerations

Factor	Impact	Mitigation
File Size	Larger files take longer	Prioritize small critical files
File Count	Many files increase overhead	Use prefix filtering
Geographic Distance	Increases latency	Choose nearby regions
Source Activity	High write activity can cause lag	Consider batching updates
Network Bandwidth	Limited bandwidth slows replication	Monitor and scale as needed

---

Additional Resources

• Azure Blob Storage Object Replication
• Configure Object Replication
• Object Replication Policy Management
• Blob Versioning and Object Replication