Maison/phpAduc/ArchiveGDrive.md

# Guide d'archivage Google Drive - Gestion des départs

Ce guide détaille la procédure complète pour archiver les données Google Drive d'une personne quittant l'organisation.

## 1. Préparation de l'archivage

### Prérequis administrateur :
- **Droits administrateur** sur Google Workspace
- **Accès au compte** de la personne qui part
- **Espace de stockage** suffisant pour l'archive
- **Outils de sauvegarde** installés

### Inventaire des données :
1. **Mon Drive** : Documents personnels de l'utilisateur
2. **Partagé avec moi** : Fichiers partagés par d'autres utilisateurs
3. **Drives partagés** : Drives d'équipe dont l'utilisateur est membre
4. **Photos Google** : Si activé sur le compte professionnel

## 2. Méthodes de sauvegarde

### Méthode 1 : Google Takeout (Recommandée)

#### Étapes pour l'administrateur :
1. **Accéder à Google Admin Console** :
   - Se connecter à [admin.google.com](https://admin.google.com)
   - Naviguer vers **Utilisateurs** → Sélectionner l'utilisateur

2. **Initier Google Takeout** :
   - Dans le profil utilisateur, cliquer sur **Plus d'actions**
   - Sélectionner **Exporter les données**
   - Ou aller directement sur [takeout.google.com](https://takeout.google.com)

3. **Configuration de l'export** :
   ```
   Services à exporter :
   ✓ Drive et Documents
   ✓ Photos (si applicable)
   ✓ Agenda (si nécessaire)
   ✓ Contacts (si nécessaire)
   
   Format de fichier :
   - Documents : .docx, .xlsx, .pptx (ou formats Google)
   - Méthode de livraison : Téléchargement ou Google Drive
   - Taille des archives : 2 GB, 4 GB, 10 GB ou 50 GB
   - Format d'archive : .zip ou .tgz
   ```

4. **Lancement de l'export** :
   - Cliquer sur **Créer l'export**
   - Attendre la notification de fin de traitement
   - Télécharger les archives générées

### Méthode 2 : Google Drive Desktop

#### Installation et configuration :
```bash
# Installation sur Linux (via Snap)
sudo snap install google-drive-desktop

# Ou téléchargement depuis le site Google
wget https://dl.google.com/drive-file-stream/GoogleDriveSetup.exe
```

#### Synchronisation complète :
1. **Installer Google Drive Desktop** sur un poste administrateur
2. **Se connecter avec le compte de l'utilisateur**
3. **Configurer la synchronisation** :
   - Sélectionner **"Mettre en miroir les fichiers"**
   - Choisir **"Synchroniser tout"**
   - Attendre la synchronisation complète

4. **Copier les données locales** :
   ```bash
   # Créer l'archive locale
   cp -r "/home/user/Google Drive" "/archives/gdrive_[nom_utilisateur]_$(date +%Y%m%d)"
   ```

### Méthode 3 : API Google Drive (Avancée)

#### Script Python pour archivage automatisé :
```python
#!/usr/bin/env python3
import os
import io
from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload
from google.oauth2.service_account import Credentials

def backup_gdrive(user_email, backup_path):
    """
    Sauvegarde complète du Google Drive d'un utilisateur
    """
    # Configuration des credentials
    credentials = Credentials.from_service_account_file(
        'service-account-key.json',
        scopes=['https://www.googleapis.com/auth/drive.readonly']
    )
    
    # Délégation pour l'utilisateur
    delegated_credentials = credentials.with_subject(user_email)
    service = build('drive', 'v3', credentials=delegated_credentials)
    
    # Lister tous les fichiers
    results = service.files().list(
        q="trashed=false",
        pageSize=1000,
        fields="nextPageToken, files(id, name, mimeType, parents)"
    ).execute()
    
    items = results.get('files', [])
    
    # Créer la structure de backup
    os.makedirs(backup_path, exist_ok=True)
    
    for item in items:
        download_file(service, item, backup_path)

def download_file(service, file_item, backup_path):
    """
    Télécharge un fichier spécifique
    """
    file_id = file_item['id']
    file_name = file_item['name']
    mime_type = file_item['mimeType']
    
    # Gestion des différents types de fichiers
    if 'google-apps' in mime_type:
        # Export des documents Google
        export_formats = {
            'application/vnd.google-apps.document': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
            'application/vnd.google-apps.spreadsheet': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            'application/vnd.google-apps.presentation': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
        }
        
        if mime_type in export_formats:
            request = service.files().export_media(
                fileId=file_id,
                mimeType=export_formats[mime_type]
            )
        else:
            return  # Type non supporté
    else:
        # Fichiers normaux
        request = service.files().get_media(fileId=file_id)
    
    # Téléchargement
    file_path = os.path.join(backup_path, file_name)
    fh = io.FileIO(file_path, 'wb')
    downloader = MediaIoBaseDownload(fh, request)
    
    done = False
    while done is False:
        status, done = downloader.next_chunk()
```

## 3. Gestion des permissions et partages

### Audit des partages :
1. **Identifier les fichiers partagés** :
   - Dans Google Admin Console → **Rapports** → **Drive**
   - Exporter la liste des fichiers partagés en externe

2. **Transférer la propriété** :
   ```bash
   # Script pour transfert de propriété
   # Utiliser l'API Admin SDK pour automatiser
   ```

3. **Documenter les accès** :
   - Liste des fichiers avec permissions externes
   - Collaborateurs internes à prévenir
   - Drives partagés à maintenir

### Script de transfert de propriété :
```python
def transfer_ownership(service, file_id, new_owner_email):
    """
    Transfère la propriété d'un fichier
    """
    permission = {
        'type': 'user',
        'role': 'owner',
        'emailAddress': new_owner_email
    }
    
    return service.permissions().create(
        fileId=file_id,
        body=permission,
        transferOwnership=True
    ).execute()
```

## 4. Structure d'archivage recommandée

```
Archive_GDrive_[Nom_Personne]_[Date]/
├── Mon_Drive/
│   ├── Documents/
│   ├── Presentations/
│   ├── Feuilles_calcul/
│   └── Autres_fichiers/
├── Drives_partages/
│   ├── [Nom_Drive_1]/
│   └── [Nom_Drive_2]/
├── Partages_recus/
│   └── fichiers_partages/
├── Metadata/
│   ├── permissions_report.csv
│   ├── file_inventory.json
│   └── sharing_audit.txt
└── Documentation/
    ├── procedure_archivage.md
    └── contacts_a_prevenir.txt
```

## 5. Vérification et validation

### Contrôles d'intégrité :
```bash
# Vérifier le nombre de fichiers
find Archive_GDrive_* -type f | wc -l

# Calculer la taille totale
du -sh Archive_GDrive_*

# Créer des checksums
find Archive_GDrive_* -type f -exec sha256sum {} \; > checksums.txt
```

### Tests de restauration :
1. **Échantillonnage** : Tester 10% des fichiers archivés
2. **Ouverture** : Vérifier que les documents s'ouvrent correctement
3. **Intégrité** : Comparer les checksums

## 6. Suppression sécurisée du compte

### Avant suppression :
- [ ] Archivage complet validé
- [ ] Transferts de propriété effectués
- [ ] Collaborateurs prévenus
- [ ] Documentation complète

### Étapes de suppression :
1. **Suspendre le compte** temporairement
2. **Vérifier** qu'aucun accès critique n'est impacté
3. **Supprimer définitivement** après validation

```bash
# Via Google Admin Console ou GAM
gam delete user user@domain.com
```

## 7. Conservation et accès

### Chiffrement de l'archive :
```bash
# Créer une archive chiffrée
tar czf - Archive_GDrive_[Nom]_[Date]/ | \
gpg --cipher-algo AES256 --compress-algo 1 --symmetric \
-o archive_gdrive_[nom]_[date].tar.gz.gpg
```

### Stockage sécurisé :
- **Stockage local chiffré**
- **Sauvegarde cloud sécurisée**
- **Accès contrôlé et tracé**

### Documentation d'accès :
```
Archive: archive_gdrive_jdupont_20251022.tar.gz.gpg
Mot de passe: [À définir selon politique entreprise]
Responsable: [Nom du responsable IT]
Date d'expiration: [Selon politique de rétention]
Contenu: 1247 fichiers, 15.2 GB
Période couverte: 2020-2025
```

## 8. Automatisation et scripts

### Script complet d'archivage :
```bash
#!/bin/bash
# Script d'archivage automatisé Google Drive

USER_EMAIL="$1"
BACKUP_DIR="/archives/gdrive"
DATE=$(date +%Y%m%d)

if [ -z "$USER_EMAIL" ]; then
    echo "Usage: $0 user@domain.com"
    exit 1
fi

# Créer le répertoire d'archive
ARCHIVE_PATH="$BACKUP_DIR/Archive_GDrive_${USER_EMAIL}_${DATE}"
mkdir -p "$ARCHIVE_PATH"

# Lancer l'archivage Python
python3 gdrive_backup.py "$USER_EMAIL" "$ARCHIVE_PATH"

# Générer les checksums
find "$ARCHIVE_PATH" -type f -exec sha256sum {} \; > "$ARCHIVE_PATH/checksums.txt"

# Créer l'archive finale
tar czf "$ARCHIVE_PATH.tar.gz" -C "$BACKUP_DIR" "Archive_GDrive_${USER_EMAIL}_${DATE}"

echo "Archive créée: $ARCHIVE_PATH.tar.gz"
```

## 9. Check-list de départ

### Avant l'archivage :
- [ ] Inventaire complet des données Google Drive
- [ ] Identification des fichiers critiques
- [ ] Liste des collaborateurs à prévenir
- [ ] Validation de l'espace de stockage disponible

### Pendant l'archivage :
- [ ] Export via Google Takeout lancé
- [ ] Synchronisation Google Drive Desktop
- [ ] Transfert des propriétés de fichiers critiques
- [ ] Documentation des partages externes

### Après l'archivage :
- [ ] Validation de l'intégrité de l'archive
- [ ] Test de restauration d'échantillons
- [ ] Chiffrement de l'archive finale
- [ ] Suppression sécurisée du compte
- [ ] Documentation de l'emplacement d'archive

---

**Note importante** : Cette procédure garantit une sauvegarde complète et sécurisée des données Google Drive tout en respectant les bonnes pratiques de gestion des départs d'employés et la continuité des collaborations.

**Date de création** : 22 octobre 2025