ROMFASTSQL/oracle/standby-server-scripts/IMPLEMENTARE_PAS_CU_PAS.md

# 🚀 GHID IMPLEMENTARE DR BACKUP - PAS CU PAS
## Oracle ROA Contabilitate: PRIMARY (10.0.20.36) → DR (10.0.20.37)

**Data implementare:** 2025-10-08
**Status:** Ready to Execute
**Durată totală estimată:** 60-90 minute

---

## ✅ PRE-VERIFICĂRI (COMPLETATE)

| Verificare | Status | Detalii |
|------------|--------|---------|
| DR Server operațional | ✅ | Container oracle-standby UP |
| Spațiu disk DR | ✅ | 93GB liberi (suficient) |
| Directoare DR | ✅ | `/opt/oracle/backups/primary/` există |
| Script-uri DR | ✅ | `full_dr_restore.sh` instalat |
| Script-uri locale | ✅ | Toate scripturile pregătite |
| PRIMARY SSH access | ✅ | SSH pe port 22122 funcțional |

---

## 📋 PLAN IMPLEMENTARE

Implementarea se face în **4 FAZE**:

### **FAZA 1:** Setup SSH Keys (30 minute)
### **FAZA 2:** Upgrade RMAN Backup Script (15 minute)
### **FAZA 3:** Instalare Transfer Script (15 minute)
### **FAZA 4:** Setup Task Scheduler (10 minute)
### **FAZA 5:** Testing (30-60 minute)

---

## 🔐 FAZA 1: SETUP SSH KEYS (30 minute)

### Pas 1.1: Conectare la PRIMARY server

```powershell
# CONECTEAZĂ-TE la PRIMARY server 10.0.20.36
# Folosește RDP sau SSH:
ssh -p 22122 romfast@10.0.20.36

# SAU deschide PowerShell direct pe PRIMARY
```

### Pas 1.2: Verificare SSH client instalat

```powershell
# În PowerShell pe PRIMARY:
Get-Command ssh

# Output așteptat:
# CommandType     Name        Version    Source
# -----------     ----        -------    ------
# Application     ssh.exe     ...        C:\Windows\System32\OpenSSH\ssh.exe

# Dacă SSH nu e instalat, instalează OpenSSH:
# Settings > Apps > Optional Features > Add OpenSSH Client
```

### Pas 1.3: Generare SSH Key Pair

```powershell
# Pe PRIMARY - în PowerShell ca Administrator (sau user Oracle)
# IMPORTANT: Rulează ca user-ul care va fi folosit pentru Task Scheduler

# Verifică user curent:
whoami
# Output: DOMAIN\Administrator sau DOMAIN\Oracle

# Generare SSH key:
ssh-keygen -t rsa -b 4096 -f "$env:USERPROFILE\.ssh\id_rsa" -N '""'

# Output așteptat:
# Generating public/private rsa key pair.
# Your identification has been saved in C:\Users\Administrator\.ssh\id_rsa
# Your public key has been saved in C:\Users\Administrator\.ssh\id_rsa.pub
```

### Pas 1.4: Afișare și copiere Public Key

```powershell
# Afișează public key:
Get-Content "$env:USERPROFILE\.ssh\id_rsa.pub"

# Output (un exemplu):
# ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC... user@hostname

# COPIAZĂ ÎNTREGUL OUTPUT (toată linia - e lungă!)
```

### Pas 1.5: Adăugare Public Key pe DR Server

**OPȚIUNEA A: Direct din PRIMARY (recomandat - mai rapid)**

```powershell
# Pe PRIMARY - trimite direct cheia pe DR:
$pubKey = Get-Content "$env:USERPROFILE\.ssh\id_rsa.pub"

# Conectare la DR și adăugare key (o să ceară parolă ROOT o singură dată):
ssh root@10.0.20.37 "mkdir -p /root/.ssh && chmod 700 /root/.ssh && echo '$pubKey' >> /root/.ssh/authorized_keys && chmod 600 /root/.ssh/authorized_keys"

# Dacă apare eroare "Permission denied", rulează manual Opțiunea B de mai jos
```

**OPȚIUNEA B: Manual pe DR Server (backup plan)**

```bash
# Deschide o nouă sesiune SSH către DR:
ssh root@10.0.20.37

# Creare director SSH:
mkdir -p /root/.ssh
chmod 700 /root/.ssh

# Editare authorized_keys:
nano /root/.ssh/authorized_keys

# PASTE cheia publică copiată la Pas 1.4 (click dreapta în terminal = paste)
# Salvează: Ctrl+X, apoi Y, apoi Enter

# Setare permissions:
chmod 600 /root/.ssh/authorized_keys

# Verificare:
cat /root/.ssh/authorized_keys
# Ar trebui să vezi cheia publică

# Exit din DR:
exit
```

### Pas 1.6: Test Conexiune SSH Passwordless

```powershell
# Pe PRIMARY - test conexiune FĂRĂ parolă:
ssh -i "$env:USERPROFILE\.ssh\id_rsa" -o "StrictHostKeyChecking=no" root@10.0.20.37 "echo 'SSH OK'"

# Output așteptat:
# SSH OK

# Dacă cere parolă = ceva nu e OK, verifică pașii anteriori!
# Dacă vezi "SSH OK" FĂRĂ să fi introdus parolă = SUCCESS! ✅
```

### Pas 1.7: Verificare finală SSH pentru SYSTEM account

⚠️ **IMPORTANT:** Task Scheduler va rula ca **SYSTEM** account, deci trebuie să configurăm SSH keys pentru SYSTEM.

```powershell
# Pe PRIMARY - rulează ca Administrator:

# Creează director SSH pentru SYSTEM account:
New-Item -ItemType Directory -Force -Path "C:\Windows\System32\config\systemprofile\.ssh"

# Copiază SSH keys de la user curent la SYSTEM:
Copy-Item "$env:USERPROFILE\.ssh\id_rsa*" "C:\Windows\System32\config\systemprofile\.ssh\"

# Verificare:
Test-Path "C:\Windows\System32\config\systemprofile\.ssh\id_rsa"
# Ar trebui să returneze: True

# Test conexiune ca SYSTEM (folosind PsExec dacă e disponibil):
# SAU lasă testarea pentru Task Scheduler la FAZA 4
```

---

## 📦 FAZA 2: UPGRADE RMAN BACKUP SCRIPT (15 minute)

### Pas 2.1: Backup script vechi

```powershell
# Pe PRIMARY:
# Verifică că scriptul existent există:
Test-Path "D:\rman_backup\rman_backup.txt"
# Ar trebui să returneze: True

# BACKUP scriptul vechi (IMPORTANT - safety!):
Copy-Item "D:\rman_backup\rman_backup.txt" "D:\rman_backup\rman_backup.txt.backup_$(Get-Date -Format 'yyyyMMdd_HHmmss')"

# Verificare backup creat:
Get-ChildItem "D:\rman_backup\rman_backup.txt.backup_*"
# Ar trebui să vezi fișierul backup

# OPȚIONAL - Afișează conținut script vechi pentru referință:
Get-Content "D:\rman_backup\rman_backup.txt"
```

### Pas 2.2: Transfer script nou de pe WSL

```powershell
# OPȚIUNEA A: Transfer direct din WSL mount point (dacă e accesibil):
Copy-Item "\\wsl$\Ubuntu\mnt\e\proiecte\ROMFASTSQL\oracle\standby-server-scripts\01_rman_backup_upgraded.txt" "D:\rman_backup\rman_backup.txt" -Force

# OPȚIUNEA B: Dacă PRIMARY nu are acces la WSL, copiază manual:
# 1. Pe WSL/local machine, deschide fișierul:
#    cat /mnt/e/proiecte/ROMFASTSQL/oracle/standby-server-scripts/01_rman_backup_upgraded.txt
# 2. Copiază conținutul
# 3. Pe PRIMARY, editează:
#    notepad D:\rman_backup\rman_backup.txt
# 4. ÎNLOCUIEȘTE tot conținutul cu cel copiat
# 5. Salvează (Ctrl+S)
```

**CONȚINUT Script Nou (pentru referință - copiază asta dacă Opțiunea B):**

```sql
RUN {
    CONFIGURE RETENTION POLICY TO REDUNDANCY 2;
    CONFIGURE CONTROLFILE AUTOBACKUP ON;
    CONFIGURE DEVICE TYPE DISK PARALLELISM 2 BACKUP TYPE TO COMPRESSED BACKUPSET;

    ALLOCATE CHANNEL ch1 DEVICE TYPE DISK;
    ALLOCATE CHANNEL ch2 DEVICE TYPE DISK;

    # Full backup COMPRESSED + Archive logs (șterge logs după backup)
    BACKUP AS COMPRESSED BACKUPSET
        INCREMENTAL LEVEL 0
        CUMULATIVE
        DEVICE TYPE DISK
        TAG 'DAILY_FULL_COMPRESSED'
        DATABASE
        INCLUDE CURRENT CONTROLFILE
        PLUS ARCHIVELOG
        DELETE INPUT;

    # Backup SPFILE separat
    BACKUP AS COMPRESSED BACKUPSET SPFILE;

    # Verificare backup integrity IMEDIAT după creare
    BACKUP VALIDATE CHECK LOGICAL DATABASE;

    # Cleanup old backups (păstrează ultimele 2 - REDUNDANCY 2)
    ALLOCATE CHANNEL FOR MAINTENANCE TYPE DISK;
    DELETE NOPROMPT OBSOLETE DEVICE TYPE DISK;
    RELEASE CHANNEL;

    RELEASE CHANNEL ch1;
    RELEASE CHANNEL ch2;
}
```

### Pas 2.3: Verificare script nou instalat

```powershell
# Pe PRIMARY:
# Afișează script nou:
Get-Content "D:\rman_backup\rman_backup.txt"

# Verifică că are:
# - REDUNDANCY 2 (la linia 2)
# - COMPRESSED BACKUPSET
# - PLUS ARCHIVELOG DELETE INPUT
# - BACKUP VALIDATE CHECK LOGICAL
```

### Pas 2.4: Test RMAN backup upgraded (OPȚIONAL - ia timp!)

⚠️ **ATENȚIE:** Acest test va rula un backup complet (~20-30 minute). Recomandabil doar dacă ai timp SAU lasă să ruleze automat în noaptea următoare.

```powershell
# Pe PRIMARY - dacă vrei să testezi ACUM:
cd D:\rman_backup

# Rulează manual backup-ul (durează 20-30 min):
.\rman_backup.bat

# Monitorizează în alt terminal:
# Tail la Oracle alert log pentru a vedea progresul
# SAU verifică mărimea fișierelor în FRA:
Get-ChildItem "C:\Users\Oracle\recovery_area\ROA\BACKUPSET" -Recurse -File |
    Sort-Object LastWriteTime -Descending | Select-Object -First 10 |
    Format-Table Name, @{L="Size(MB)";E={[math]::Round($_.Length/1MB,2)}}, LastWriteTime

# Ar trebui să vezi fișiere noi .BKP cu compression (mai mici decât înainte)
```

---

## 📤 FAZA 3: INSTALARE TRANSFER SCRIPT (15 minute)

### Pas 3.1: Creare director logs

```powershell
# Pe PRIMARY:
New-Item -ItemType Directory -Force -Path "D:\rman_backup\logs"

# Verificare:
Test-Path "D:\rman_backup\logs"
# Ar trebui să returneze: True
```

### Pas 3.2: Transfer script PowerShell

```powershell
# OPȚIUNEA A: Transfer direct din WSL:
Copy-Item "\\wsl$\Ubuntu\mnt\e\proiecte\ROMFASTSQL\oracle\standby-server-scripts\02_transfer_to_dr.ps1" "D:\rman_backup\transfer_to_dr.ps1" -Force

# OPȚIUNEA B: Dacă PRIMARY nu vede WSL, folosește transfer prin SSH:
# Pe WSL/local machine:
scp -P 22122 /mnt/e/proiecte/ROMFASTSQL/oracle/standby-server-scripts/02_transfer_to_dr.ps1 romfast@10.0.20.36:/d/rman_backup/

# Verificare pe PRIMARY:
Test-Path "D:\rman_backup\transfer_to_dr.ps1"
# Ar trebui să returneze: True
```

### Pas 3.3: Verificare parametri script

```powershell
# Pe PRIMARY - afișează header script:
Get-Content "D:\rman_backup\transfer_to_dr.ps1" -Head 15

# Verifică parametrii default:
# - SourceFRA = "C:\Users\Oracle\recovery_area\ROA"  ✅
# - DRHost = "10.0.20.37"  ✅
# - DRUser = "root"  ✅
# - DRPath = "/opt/oracle/backups/primary"  ✅
# - SSHKeyPath = "$env:USERPROFILE\.ssh\id_rsa"  ✅
# - MaxBackupsOnDR = 1  ✅ (păstrează doar ultimul backup pe DR)
```

### Pas 3.4: Test manual transfer script

⚠️ **ATENȚIE:** Acest test va transfera backup-urile existente către DR. Durează ~10-15 minute în funcție de mărimea backup-urilor.

```powershell
# Pe PRIMARY - test manual:
PowerShell -ExecutionPolicy Bypass -NoProfile -File "D:\rman_backup\transfer_to_dr.ps1"

# Output așteptat:
# [2025-10-08 HH:MM:SS] [INFO] Oracle DR Backup Transfer Started
# [2025-10-08 HH:MM:SS] [INFO] Testing SSH connection to 10.0.20.37...
# [2025-10-08 HH:MM:SS] [SUCCESS] SSH connection successful
# [2025-10-08 HH:MM:SS] [INFO] Waiting for RMAN backup to complete...
# [2025-10-08 HH:MM:SS] [INFO] Searching for today's backup files...
# [2025-10-08 HH:MM:SS] [INFO] Found X files, total size: Y GB
# [2025-10-08 HH:MM:SS] [INFO] Transferring: filename.BKP (XXX MB)
# [2025-10-08 HH:MM:SS] [SUCCESS] ✅ Transferred: filename.BKP
# ...
# [2025-10-08 HH:MM:SS] [INFO] Transfer summary: X succeeded, 0 failed
# [2025-10-08 HH:MM:SS] [INFO] DR Backup Transfer Completed Successfully

# Dacă apare EROARE, verifică:
# - SSH connection (Pas 1.6)
# - Directoare DR (verificate în PRE-VERIFICĂRI)
# - Backup-uri există în FRA (verifică cu Get-ChildItem)
```

### Pas 3.5: Verificare fișiere transferate pe DR

```powershell
# Pe PRIMARY - verifică remote pe DR:
ssh -i "$env:USERPROFILE\.ssh\id_rsa" root@10.0.20.37 "ls -lh /opt/oracle/backups/primary/"

# Ar trebui să vezi fișierele .BKP transferate
# Exemplu output:
# -rw-r--r-- 1 root root 2.1G Oct  8 03:15 o1_mf_nnnd0_DAILY_FULL_COMPRESSED_mfxxx.BKP
# -rw-r--r-- 1 root root  45M Oct  8 03:20 o1_mf_ncsnf_TAG20251008T0315_mfxxx.BKP
```

### Pas 3.6: Verificare log transfer

```powershell
# Pe PRIMARY:
$logFile = Get-ChildItem "D:\rman_backup\logs\transfer_*.log" | Sort-Object LastWriteTime -Descending | Select-Object -First 1

# Afișează ultimele 30 linii din log:
Get-Content $logFile -Tail 30

# Caută erori:
Select-String -Path $logFile -Pattern "ERROR|FAILED"
# Dacă nu returnează nimic = totul OK! ✅
```

---

## ⏰ FAZA 4: SETUP TASK SCHEDULER (10 minute)

### Pas 4.1: Verificare script setup există

```powershell
# Pe PRIMARY - verifică că ai scriptul de setup:
# OPȚIUNEA A: Transfer din WSL:
Copy-Item "\\wsl$\Ubuntu\mnt\e\proiecte\ROMFASTSQL\oracle\standby-server-scripts\03_setup_dr_transfer_task.ps1" "D:\rman_backup\setup_task.ps1" -Force

# OPȚIUNEA B: Transfer prin SCP:
# Pe WSL: scp -P 22122 /mnt/e/proiecte/ROMFASTSQL/oracle/standby-server-scripts/03_setup_dr_transfer_task.ps1 romfast@10.0.20.36:/d/rman_backup/setup_task.ps1
```

### Pas 4.2: Rulare script setup (ca Administrator!)

```powershell
# Pe PRIMARY - DESCHIDE PowerShell ca Administrator!
# Click dreapta pe PowerShell > Run as Administrator

# Verifică că ești Administrator:
([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
# Ar trebui să returneze: True

# Rulează script setup:
PowerShell -ExecutionPolicy Bypass -File "D:\rman_backup\setup_task.ps1"

# Output așteptat:
# Setting up Oracle DR Transfer scheduled task...
# Created log directory: D:\rman_backup\logs
# ✅ Task created successfully: Oracle_DR_Transfer
#
# Task details:
#   Name:        Oracle_DR_Transfer
#   Schedule:    Daily at 03:00 AM
#   Script:      D:\rman_backup\transfer_to_dr.ps1
#   Logs:        D:\rman_backup\logs\transfer_YYYYMMDD.log
#
# Task status: Ready
```

### Pas 4.3: Verificare Task creat

```powershell
# Pe PRIMARY:
Get-ScheduledTask -TaskName "Oracle_DR_Transfer" | Format-List *

# Verifică:
# - TaskName: Oracle_DR_Transfer
# - State: Ready
# - Triggers: Daily at 03:00 AM
# - Actions: PowerShell with transfer_to_dr.ps1

# SAU vizualizează în Task Scheduler GUI:
taskschd.msc
# Caută task-ul "Oracle_DR_Transfer" în Task Scheduler Library
```

### Pas 4.4: Test manual task (OPȚIONAL)

```powershell
# Pe PRIMARY - test rulare manuală:
Start-ScheduledTask -TaskName "Oracle_DR_Transfer"

# Monitorizează status:
Get-ScheduledTask -TaskName "Oracle_DR_Transfer" | Select-Object Name, State, LastRunTime, LastTaskResult

# Verifică log:
Start-Sleep -Seconds 60  # Așteaptă să se termine
Get-Content "D:\rman_backup\logs\transfer_$(Get-Date -Format 'yyyyMMdd').log" -Tail 20
```

---

## 🧪 FAZA 5: TESTING ȘI VALIDARE (30-60 minute)

### Test 1: Verificare calendar backup existent

```powershell
# Pe PRIMARY - verifică task-ul RMAN existent:
Get-ScheduledTask | Where-Object {$_.TaskName -like "*backup*" -or $_.TaskName -like "*RMAN*"} |
    Select-Object TaskName, State, @{L="Trigger";E={(Get-ScheduledTaskInfo $_).NextRunTime}}

# Identifică task-ul de la 02:00 AM
# Verifică task-ul MareBackup de la 21:00
```

### Test 2: Verificare flow complet (simulare)

```
02:00 AM → RMAN Backup (EXISTENT - upgradat)
   ↓
03:00 AM → Transfer DR (NOU - instalat)
   ↓
21:00 PM → MareBackup HDD E:\ (EXISTENT - nu modificat)
```

**Verificare:**
1. RMAN backup task există și e setat pentru 02:00 AM
2. DR transfer task există și e setat pentru 03:00 AM (DUPĂ RMAN)
3. MareBackup task există și e setat pentru 21:00 (DUPĂ toate)

### Test 3: Verificare spațiu disk

```powershell
# Pe PRIMARY:
Get-PSDrive C,D,E | Format-Table Name,
    @{L="Used(GB)";E={[math]::Round($_.Used/1GB,1)}},
    @{L="Free(GB)";E={[math]::Round($_.Free/1GB,1)}},
    @{L="Total(GB)";E={[math]::Round(($_.Used+$_.Free)/1GB,1)}},
    @{L="Use%";E={[math]::Round($_.Used/($_.Used+$_.Free)*100,0)}}

# Verifică că:
# - C:\ are >10GB free (pentru FRA și temp)
# - D:\ are >20GB free (pentru scripts și logs)
# - E:\ variabil (HDD extern)
```

```bash
# Pe DR:
ssh root@10.0.20.37 "df -h /opt/oracle"

# Verifică că ai >50GB free (pentru 3+ zile de backups compressed)
```

### Test 4: Test restore pe DR (RECOMANDAT - durează 45-75 min)

⚠️ **IMPORTANT:** Acest test validează că backup-urile transferate FUNCȚIONEAZĂ și pot fi folosite pentru disaster recovery!

```bash
# Pe DR Server:
ssh root@10.0.20.37

# Verifică că backup-uri există:
ls -lh /opt/oracle/backups/primary/

# Rulează test restore (DOAR dacă ai timpul disponibil):
/opt/oracle/scripts/dr/05_test_restore_dr.sh

# Monitorizează progres:
tail -f /opt/oracle/logs/dr/test_restore_*.log

# După 45-75 minute, verifică raport:
cat /opt/oracle/logs/dr/test_report_$(date +%Y%m%d).txt

# ⚠️ IMPORTANT: După test, OPREȘTE database pe DR!
docker exec -u oracle oracle-standby bash -c "
export ORACLE_SID=ROA
export ORACLE_HOME=/opt/oracle/product/19c/dbhome_1
\$ORACLE_HOME/bin/sqlplus / as sysdba <<< 'SHUTDOWN IMMEDIATE;'
"

# Exit din DR:
exit
```

---

## 📊 POST-IMPLEMENTATION MONITORING

### Zi 1 (mâine dimineață):

```powershell
# Pe PRIMARY - verifică că totul a rulat OK noaptea trecută:

# Check 1: RMAN backup (02:00 AM)
$lastBackup = Get-ChildItem "C:\Users\Oracle\recovery_area\ROA\BACKUPSET" -Recurse -File |
    Sort-Object LastWriteTime -Descending | Select-Object -First 1
$age = (Get-Date) - $lastBackup.LastWriteTime
Write-Host "Last RMAN backup: $($lastBackup.Name)"
Write-Host "Age: $($age.Hours) hours $($age.Minutes) minutes"
# Ar trebui să fie <12 ore (backup de azi-noapte la 02:00)

# Check 2: Transfer DR (03:00 AM)
$transferLog = Get-ChildItem "D:\rman_backup\logs\transfer_*.log" |
    Sort-Object LastWriteTime -Descending | Select-Object -First 1
Write-Host "`nTransfer log: $($transferLog.Name)"
Get-Content $transferLog -Tail 10
# Ar trebui să vezi "Transfer Completed Successfully"

# Check 3: MareBackup HDD (21:00)
Get-ChildItem "E:\backup_roa\" -Recurse |
    Sort-Object LastWriteTime -Descending | Select-Object -First 5 |
    Format-Table Name, @{L="Size(MB)";E={[math]::Round($_.Length/1MB,2)}}, LastWriteTime
```

```bash
# Pe DR - verifică backup-uri primite:
ssh root@10.0.20.37 "ls -lth /opt/oracle/backups/primary/ | head -10"

# Ar trebui să vezi fișiere noi de azi-noapte
```

### Săptămânal (Luni dimineața):

```powershell
# Quick health check:
Get-Content "D:\rman_backup\logs\transfer_*.log" | Select-String "ERROR|FAILED"
# Dacă nu returnează nimic = totul OK!

# Verifică spațiu disk:
Get-PSDrive C,D,E | Format-Table Name, @{L="Free(GB)";E={[math]::Round($_.Free/1GB,1)}}
```

### Lunar (Prima Duminică):

```bash
# Test restore complet pe DR (OBLIGATORIU!):
ssh root@10.0.20.37 "/opt/oracle/scripts/dr/05_test_restore_dr.sh"

# Verifică raport și documentează RTO/RPO
```

---

## 🚨 TROUBLESHOOTING

### Problem: "SSH connection refused"

```powershell
# Test conectivitate:
ping 10.0.20.37

# Test SSH manual:
ssh -v -i "$env:USERPROFILE\.ssh\id_rsa" root@10.0.20.37 "echo OK"

# Soluții:
# 1. Verifică DR server pornit
# 2. Verifică firewall permite port 22
# 3. Re-generare SSH keys (vezi FAZA 1)
```

### Problem: "RMAN backup failed"

```powershell
# Check Oracle alert log:
# Găsește alert.log în $ORACLE_BASE/diag/rdbms/roa/ROA/trace/

# Check FRA space:
sqlplus / as sysdba
SELECT * FROM v$recovery_area_usage;

# Cleanup manual dacă e plin:
RMAN> DELETE NOPROMPT OBSOLETE;
```

### Problem: "Transfer failed - no files found"

```powershell
# Verifică că backup RMAN a rulat:
Get-ChildItem "C:\Users\Oracle\recovery_area\ROA\BACKUPSET" -Recurse -File |
    Sort-Object LastWriteTime -Descending | Select-Object -First 5

# Verifică că fișierele sunt din azi:
# Ar trebui să vezi LastWriteTime = azi după 02:00 AM
```

---

## ✅ CHECKLIST FINAL

### Pre-Implementation:
- [x] DR Server operațional (container oracle-standby UP)
- [x] Spațiu disk verificat (93GB liberi pe DR)
- [x] Directoare create (`/opt/oracle/backups/primary/`)
- [x] Script-uri locale pregătite (toate .ps1, .txt, .sh)

### FAZA 1 - SSH Keys:
- [ ] SSH key pair generat pe PRIMARY
- [ ] Public key copiat pe DR
- [ ] Test conexiune passwordless OK
- [ ] SSH keys copiate pentru SYSTEM account

### FAZA 2 - RMAN Upgrade:
- [ ] Script vechi backed up
- [ ] Script nou instalat cu REDUNDANCY 2
- [ ] Verificat conținut script nou
- [ ] Test backup (opțional)

### FAZA 3 - Transfer Script:
- [ ] Director logs creat
- [ ] Script transfer_to_dr.ps1 instalat
- [ ] Test manual transfer OK
- [ ] Fișiere verificate pe DR
- [ ] Log transfer fără erori

### FAZA 4 - Task Scheduler:
- [ ] Script setup rulat ca Administrator
- [ ] Task "Oracle_DR_Transfer" creat
- [ ] Task verificat (Ready, 03:00 AM daily)
- [ ] Test manual task (opțional)

### FAZA 5 - Testing:
- [ ] Flow complet verificat (02:00 → 03:00 → 21:00)
- [ ] Spațiu disk verificat (PRIMARY și DR)
- [ ] Test restore pe DR (recomandat)
- [ ] Database DR oprit după test

### Post-Implementation:
- [ ] Monitorizare Zi 1 (mâine dimineață)
- [ ] Monitorizare săptămânală
- [ ] Schedule primul test restore lunar

---

## 📞 CONTACT ȘI ESCALATION

| Issue | Response Time | Action |
|-------|---------------|--------|
| **PRIMARY Down** | Immediate | Activate DR (`full_dr_restore.sh` pe 10.0.20.37) |
| **Backup Failed** | 2 hours | Check logs, retry manual |
| **Transfer Failed** | 4 hours | Verifică SSH, retry |

---

## 📄 FIȘIERE IMPORTANTE

**Pe PRIMARY (10.0.20.36):**
```
D:\rman_backup\
├── rman_backup.bat              # Launcher existent
├── rman_backup.txt              # UPGRADED cu compression
├── rman_backup.txt.backup_*     # Backup vechi (safety)
├── transfer_to_dr.ps1           # NOU - transfer script
├── setup_task.ps1               # Setup Task Scheduler
└── logs\
    └── transfer_YYYYMMDD.log    # Transfer logs
```

**Pe DR (10.0.20.37):**
```
/opt/oracle/backups/primary/     # Backup-uri primite
/opt/oracle/scripts/dr/          # Restore scripts
/opt/oracle/logs/dr/             # Restore logs
```

---

## 🎯 NEXT STEPS

1. ✅ **CITEȘTE acest ghid complet**
2. 🔜 **EXECUTĂ FAZA 1** (SSH Keys)
3. 🔜 **EXECUTĂ FAZA 2** (RMAN Upgrade)
4. 🔜 **EXECUTĂ FAZA 3** (Transfer Script)
5. 🔜 **EXECUTĂ FAZA 4** (Task Scheduler)
6. 🔜 **EXECUTĂ FAZA 5** (Testing)
7. 📅 **MONITORIZEAZĂ** primele 3 zile
8. 📅 **SCHEDULE** primul test restore (luna viitoare)

---

**Document creat:** 2025-10-08
**Status:** Ready for Implementation
**Versiune:** 1.0
**Durată estimată:** 60-90 minute (exclusiv test restore opțional)

---

## 🔐 SECURITY NOTES

- SSH private key (`id_rsa`) e sensibil - NU îl partaja niciodată!
- Backup SSH keys în locație sigură offline
- Logs pot conține informații sensibile - restricționează access
- Test restore pe DR NU afectează PRIMARY (database pe DR e separat)

---

**Succes la implementare! 🚀**

**Dacă întâmpini probleme, consultă secțiunea TROUBLESHOOTING sau contactează suportul.**