easylinux/Maison
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initialisation depot

Browse Source
This commit is contained in:
Serge NOEL
2026-02-10 12:12:11 +01:00
commit c3176e8d79
818 changed files with 52573 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

335
phpAduc/ArchiveGDrive.md Normal file
View File

@@ -0,0 +1,335 @@
# 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