Un commit Git peut disparaître de l’historique visible de la branche alors que ses objets existent toujours localement. Une branche réinitialisée, rebase ou supprimée peut supprimer la référence pratique sans effacer immédiatement chaque objet sous-jacent. Cela fait des propres outils d’inspection de Git la première voie de récupération. Commencez par préserver le référentiel et le travail non validé en cours. Recherchez ensuite le commit prévu et créez une nouvelle référence plutôt que de déplacer de manière destructrice la branche actuelle.
Réponse rapide : inspectez d’abord et créez une branche de secours
Utilisez le reflog local approprié pour localiser un commit antérieur plausible, inspecter son contenu et créer une branche de secours nommée séparément lorsque le candidat a raison. Les réserves existantes ou les clones survivants autorisés fournissent différentes sources. S’il ne reste aucune référence, une inspection d’objet en lecture seule peut révéler des validations en suspens qui existent encore. Aucune de ces routes ne garantit la récupération après la suppression des objets requis ou lorsque le travail manquant n’est jamais entré dans Git.
Les outils de récupération de Git sont gratuits. Cependant, les commandes ont des effets différents et un article de récupération ne devrait pas encourager une autre réinitialisation matérielle dans un premier temps. Préservez l’état de fonctionnement actuel et inspectez les exemples avant de les adapter. Distinguez également le travail validé, le contenu intermédiaire, les fichiers non suivis, les ressources ignorées et les tampons d’éditeur non enregistrés. Une récupération de validation peut réussir alors qu’un fichier distinct non suivi reste manquant.
Identifiez l’état Git manquant
Référence perdue ou objets manquants
Enregistrez ce qui s’est passé : suppression de branche, rebase, réinitialisation, remplacement de référentiel ou répertoire de travail manquant. Un commit absent du journal actuel peut rester accessible depuis une autre branche ou balise. Commencez par les références existantes avant de rechercher des objets inaccessibles. Confirmez également le référentiel et le clone corrects. Deux dossiers portant le même nom de projet peuvent contenir des historiques locaux et des reflogs différents.
Notez un message de validation reconnaissable, un chemin, une fonction ou un test modifié. Cela vous donne un test d’acceptation pratique lorsque plusieurs candidats se ressemblent. Un message familier seul ne suffit pas car un rebase peut créer différents commits avec des descriptions associées. Inspectez les modifications réelles et l’historique des parents pertinents. L’objectif est l’état prévu du projet, pas simplement un identifiant d’objet qui ressemble à celui mémorisé sur une capture d’écran du terminal.
Préserver le contexte actuel du travail et du référentiel
Créez une copie complète appropriée du référentiel tout en évitant les modifications simultanées. Incluez les métadonnées Git pertinentes, pas seulement les fichiers sources visibles. Préservez également le travail non engagé et non suivi de manière indépendante. Un clone normal ne copie pas nécessairement les reflogs locaux ou les objets inaccessibles, il ne constitue donc pas automatiquement une copie complète des preuves pour cette enquête. Enregistrez le dossier source et la version de Git utilisée pour les tests.
Pour les arbres de travail liés, inspectez la relation réelle entre les répertoires Git avant de copier uniquement le dossier de l’arbre de travail. Ses métadonnées Git peuvent résider ailleurs. Conservez ces relations documentées et utilisez les workflows Git pris en charge. Évitez également les commandes de maintenance qui élaguent les objets alors que la récupération n’est pas résolue. Une nouvelle version ou une installation de dépendance n’est généralement pas pertinente pour retrouver une validation perdue et peut ajouter des modifications inutiles à l’environnement de travail.
Itinéraire gratuit 1 : inspectez le reflog local
- Confirmez le référentiel et conservez le travail en cours.
- Exécutez une inspection de reflog en lecture seule, telle que git reflog show –all, dans le clone concerné.
- Identifiez les entrées plausibles autour de la réinitialisation, du rebase ou du changement de branche.
- Inspectez les modifications réelles de chaque candidat avant de créer une référence de récupération.
Les relogs enregistrent les mises à jour des références locales et peuvent révéler où pointait précédemment une branche ou un HEAD. Il s’agit de preuves locales et non d’un historique universel côté serveur. Un autre clone peut avoir des entrées différentes et la rétention n’est pas indéfinie. Par conséquent, inspectez rapidement le clone où l’incident s’est produit. Ne promettez pas une fenêtre de récupération fixe sans vérifier la configuration réelle et les objets survivants.
Lisez attentivement la séquence de l’événement
Comparez les entrées avant et après l’opération qui a modifié la visibilité. Un rebase peut générer une série d’états associés, tandis qu’une réinitialisation peut déplacer directement la pointe de la branche. Inspectez un candidat avec une commande telle que git show suivie de l’identifiant réel de l’objet. Traitez l’identifiant comme une valeur à sélectionner dans votre référentiel, et non comme un espace réservé à coller littéralement. Comparez également les fichiers concernés et l’historique des parents.
Si plusieurs entrées contiennent la modification manquante, déterminez laquelle représente la ligne de travail complète prévue. Un seul commit peut dépendre de commits antérieurs inclus dans l’historique du candidat. Conservez une branche à la pointe appropriée plutôt que de copier aveuglément un patch. Cela permet de conserver la séquence de développement récupérée disponible pour examen sans forcer la branche actuelle à se déplacer immédiatement.
Itinéraire gratuit 2 : créez une référence de sauvetage distincte
- Inspectez le candidat et confirmez que les objets requis restent disponibles.
- Choisissez un nouveau nom de branche de secours inutilisé.
- Créez la branche au niveau de l’objet vérifié, par exemple avec git branch et le nom et l’identifiant choisis.
- Inspectez la nouvelle branche et comparez-la avec le travail en cours dans un espace de travail contrôlé.
La création d’une nouvelle branche fournit une référence durable au candidat sans réinitialiser la branche actuelle. La commande modifie les références du référentiel, conservez donc les preuves et sélectionnez délibérément la cible. Il ne fusionne pas automatiquement les modifications récupérées en production. Gardez cette décision d’intégration séparée. Vérifiez également que le nom choisi n’identifie pas déjà une autre branche utile avant d’adapter un exemple de commande.
Un modèle de commande est git branch recovery-example COMMIT_ID. Ici, recovery-example représente un nouveau nom de branche inutilisé et COMMIT_ID doit être remplacé par l’identifiant de validation réel vérifié de votre propre référentiel. Ne collez pas l’espace réservé littéralement. Inspectez d’abord le candidat avec git show et son véritable identifiant. La création de cette branche de secours préserve une référence sans nécessiter git reset –hard, et n’autorise pas le transfert ou le remplacement de l’historique distant partagé.
Réviser avant d’intégrer
Comparez la branche récupérée avec la base prévue et la branche actuelle. Inspectez les tests, la configuration, les migrations et les dépendances associés au changement. Un commit peut être authentique tout en ne correspondant plus à la présente application. Utilisez un espace de travail de test distinct, le cas échéant. Le rétablissement établit l’accès à un état historique ; un examen technique normal détermine comment l’intégrer en toute sécurité dans les travaux en cours.
Ne forcez pas l’historique partagé simplement pour que la branche récupérée ressemble à l’état distant précédent. Conservez d’abord une référence de sauvetage locale. Toute publication ou modification de l’historique partagé appartient au flux de travail autorisé normal du référentiel. Cette distinction empêche une récupération locale de supprimer accidentellement le travail le plus récent d’un collègue ou d’exposer un contenu inachevé qui nécessitait seulement une inspection.
Itinéraire gratuit 3 : inspecter une réserve existante
- Préservez le référentiel et l’état de fonctionnement actuel.
- Répertoriez les entrées de cache existantes via l’interface prise en charge par Git.
- Inspectez une réserve pertinente avant de l’appliquer.
- Récupérez le contenu vérifié dans un état de test distinct sans supprimer le seul candidat caché.
Une réserve peut conserver un travail qui n’est jamais devenu une validation de branche normale, mais sa couverture dépend de la manière dont il a été créé. Les fichiers non suivis ou ignorés ne sont pas automatiquement inclus dans chaque cache. Par conséquent, inspectez le contenu réel plutôt que de supposer que la cache contient tout l’espace de travail. Comparez également le commit de base et les fichiers prévus. Une réserve portant le même nom peut appartenir à une autre tâche.
Séparez l’inspection et l’application
L’inspection des réserves en lecture seule permet d’identifier un candidat sans modifier l’arborescence de travail. L’application d’une réserve peut produire des conflits ou écraser les hypothèses sur la base actuelle, utilisez donc un espace de travail contrôlé et conservez d’abord les modifications actuelles. Évitez un flux de travail pop-and-drop comme test initial lorsqu’il peut consommer le candidat le plus utile. Conservez la réserve jusqu’à ce que le contenu récupéré soit vérifié et préservé de manière indépendante.
Si une entrée de cache elle-même a disparu, ses objets peuvent ou non rester dans le référentiel. Traitez cela comme une évaluation distincte de la récupération d’objet plutôt que de promettre que la même commande de listage peut le trouver. Distinguez également une réserve de l’historique de l’éditeur. Un tampon source qui n’a jamais été enregistré ou inclus dans Git nécessite une autre source de récupération, même lorsque l’historique validé du référentiel reste totalement sain.
Voie gratuite 4 : inspecter un clone survivant autorisé
- Identifiez un clone ou une référence existante légitime pouvant contenir la validation manquante.
- Préservez son état local avant de modifier les références ou de le récupérer.
- Inspectez l’historique et le contenu réels du candidat.
- Transférez ou référencez la récupération vérifiée via un workflow Git contrôlé approprié.
Le clone autorisé d’un collègue, une autre machine personnelle ou une référence distante existante peut conserver un commit auquel le clone affecté ne fait plus référence. Cependant, un nom de suivi à distance ne garantit pas que l’état sous-jacent souhaité reste disponible. Inspectez les objets réels et l’histoire. Évitez également d’utiliser le référentiel privé ou les informations d’identification de quelqu’un d’autre sans autorisation. La source de récupération doit être celle que vous contrôlez légitimement ou que vous êtes autorisé à utiliser.
Comparer l’identité et le contenu de l’objet
Les versions rebasées d’une même modification logique peuvent avoir des identifiants d’objet différents. À l’inverse, un préfixe d’identifiant familier n’est qu’un raccourci qui doit être résolu sans ambiguïté dans le référentiel. Comparez la différence réelle et l’historique environnant. Enregistrez également quel clone a fourni le candidat. Cela permet d’expliquer pourquoi la ligne récupérée diffère d’une entrée de reflog locale et permet de maintenir la traçabilité de l’enquête.
Si le clone contient une branche utile, conservez une nouvelle référence de secours avant l’intégration. Ne synchronisez pas chaque branche sans discernement comme raccourci de récupération. Un transfert restreint de l’historique vérifié est plus facile à examiner et moins susceptible de confondre des travaux sans rapport. Ensuite, exécutez les tests appropriés et inspectez la différence résultante par rapport à l’état prévu du projet.
Itinéraire gratuit 5 : inspectez les objets suspendus survivants
- Conservez une copie complète du référentiel pertinent et évitez d’élaguer la maintenance.
- Utilisez une commande d’intégrité et d’inspection d’objets en lecture seule appropriée au référentiel.
- Inspectez les objets de commit suspendus plausibles et leur contenu.
- Créez une nouvelle référence uniquement après avoir identifié un candidat vérifié utile.
L’inspection des objets de Git peut révéler des validations ou d’autres objets qui restent sans référence de branche normale. Cependant, il ne peut pas récupérer les objets déjà supprimés de toutes les sources disponibles. De plus, les blobs et les arbres en suspens ne préservent pas automatiquement les noms de fichiers, le contexte complet du projet ou un historique de validation prêt à l’emploi. Traitez le résultat comme une preuve à inspecter, et non comme une garantie que chaque objet signalé appartient à la tâche perdue.
Ne confondez pas les avertissements avec la cible
Une base de données d’objets peut contenir des éléments inaccessibles sans rapport avec une activité normale. Comparez les parcours et le contenu reconnaissables avant de sélectionner un candidat. Enregistrez les messages d’erreur réels séparément des rapports informatifs sur les objets suspendus. Si le référentiel présente une véritable corruption, conservez-le et recherchez la voie de réparation prise en charge appropriée plutôt que d’exécuter des commandes d’écriture arbitraires jusqu’à ce qu’une erreur disparaisse.
Conservez les preuves originales du référentiel même après avoir trouvé un objet utile. Une comparaison ultérieure peut révéler qu’un autre candidat contient un test manquant ou un changement de suivi. Documentez également si le résultat restaure une séquence de validation entière ou uniquement un fragment source. Ce sont des résultats différents, et le plan d’intégration doit refléter le contexte restant que vous devez reconstruire.
Exemple : récupérer une branche après une réinitialisation non désirée
Supposons qu’un développeur réinitialise une branche de fonctionnalité à un point plus ancien et se rende compte plus tard que deux validations utiles ont disparu du journal visible. Le référentiel contient toujours leurs objets et le reflog de HEAD affiche l’astuce de branche précédente. Préserver d’abord le travail en cours. Inspectez le diff du candidat et l’historique des parents, puis créez une nouvelle branche de sauvetage à l’astuce vérifiée. La branche actuelle n’a pas besoin d’une autre réinitialisation destructrice pour cette première étape de récupération.
Ensuite, comparez la branche de sauvetage avec le travail en cours et exécutez des tests ciblés dans un espace de travail contrôlé. Si des collègues ont ajouté de nouveaux changements ailleurs, intégrez-les via le processus de révision normal plutôt que de forcer l’état historique. Enfin, conservez la récupération acceptée et documentez l’entrée de reflog source. Cela rétablit l’accès aux commits prévus tout en gardant la décision d’intégration séparée et révisable.
Valider plus que le message de validation
Inspectez les fichiers modifiés, l’historique parent, les tests, la configuration et les actifs requis du projet. Comparez ensuite le candidat avec le comportement manquant ou l’étape de développement réelle. Un commit qui se construit peut toujours représenter un état intermédiaire incomplet. Conservez également le matériel non suivi séparément là où la tâche en a besoin. La récupération Git peut renvoyer l’historique enregistré tout en laissant les données ignorées, les paramètres locaux ou les tampons non enregistrés non résolus.
Conservez le référentiel de preuves, les références de secours et l’intégration acceptée jusqu’à la fin de l’examen. Ensuite, protégez les branches ou exportations significatives via le flux de travail de sauvegarde normal. Préservez également les actifs non-Git importants de manière indépendante. Un référentiel distant et un reflog local répondent à des questions différentes, donc ni l’un ni l’autre ne doivent être traités comme une sauvegarde illimitée de chaque état apparaissant autrefois dans un éditeur.
Classer le travail perdu avant de choisir une commande
États engagés et non engagés
Une pointe de branche peut se déplacer pendant que les objets validés survivent, mais un fichier non suivi ne peut jamais entrer dans la base de données d’objets. Le contenu mis en scène et les caches introduisent d’autres possibilités. Enregistrez le flux de travail réel qui a précédé la perte. Cela empêche qu’une sauvegarde de validation réussie soit présentée comme une récupération de chaque fichier apparaissant autrefois dans le répertoire de travail. Différents États ont besoin de preuves différentes.
Pour le texte non validé manquant, inspectez l’historique de l’éditeur survivant ou les copies de l’espace de travail indépendant aux côtés de Git. Conservez également les modifications actuelles avant de tester un état historique. Ne forcez pas toutes les questions de récupération dans une recherche de reflog. Une classification claire vous aide à choisir rapidement la bonne source et évite les commandes destructrices qui déplacent la branche actuelle sans traiter le matériel manquant réel.
Chemins renommés et identité de branche
Un fichier peut apparaître manquant parce que son chemin a changé ou parce que la mauvaise branche s’est ouverte. Inspectez l’identité du référentiel, la branche et l’historique pertinent avant d’assumer une perte de données. Comparez également la différence réelle autour d’un changement de nom. Une seule recherche de nom de fichier peut manquer du contenu utile sous un autre chemin. Conservez le comportement prévu et le fragment source distinctif dans votre liste de contrôle d’acceptation.
Si plusieurs référentiels partagent un nom de projet, enregistrez le dossier source absolu pour chaque candidat. Un clone créé après l’incident peut ne pas disposer des preuves locales pertinentes, même s’il contient les mêmes branches distantes. À l’inverse, un clone personnel plus ancien peut conserver un historique utile. Comparez la disponibilité et le contenu réels des objets plutôt que de supposer que chaque clone est interchangeable à des fins de récupération.
Inspecter les candidats historiques de manière cohérente
Engagez les parents et les changements à charge
Une astuce récupérée peut inclure toute une séquence de travail, tandis qu’une validation isolée peut dépendre de modifications antérieures. Inspectez l’historique des parents et les fichiers associés. Par exemple, l’implémentation d’une fonctionnalité peut nécessiter une mise à jour du schéma ou un montage de test provenant d’un autre commit. Restaurer uniquement le fichier source le plus reconnaissable peut produire un résultat incomplet même si la validation récupérée elle-même est authentique.
Conservez une référence de sauvetage en un point utile vérifié et comparez la séquence dans un espace de travail contrôlé. Décidez ensuite comment le projet actuel doit l’intégrer dans le cadre d’un examen normal. Cela sépare l’accès aux travaux historiques de l’intégration. Cela évite également une autre réinitialisation destructrice qui ignore les changements de courant non liés simplement parce que la séquence récupérée représentait autrefois la pointe de la branche.
Modifications et identifiants rebasés
Un rebase peut créer de nouveaux identifiants d’objet pour les modifications qui ressemblent aux validations précédentes. Par conséquent, comparez les différences réelles et le contexte environnant plutôt que de traiter un message ou un identifiant court comme une preuve complète. Confirmez également qu’un identifiant abrégé est résolu sans ambiguïté dans le référentiel concerné. Un candidat d’un autre clone peut nécessiter un identifiant plus long ou un contexte de référence différent pour une inspection fiable.
Conservez la source originale du candidat documentée. Si deux versions implémentent différemment le même changement logique, conservez les deux jusqu’à ce que la révision détermine la forme acceptée. La récupération ne nécessite pas de choisir le premier message familier. Le candidat le plus fort est celui qui rétablit le comportement et le contexte souhaités tout en restant compréhensible et compatible avec le projet en cours.
Couverture des caches et conflits
Inspectez ce que contient réellement une réserve avant de l’appliquer. Ses options de création affectent si le contenu non suivi ou ignoré apparaît. Comparez également son état de base avec les travaux en cours. Une réserve d’une autre tâche peut contenir des fragments utiles ainsi que des modifications sans rapport. Préservez le candidat et utilisez un état de test contrôlé plutôt que de l’appliquer sur un arbre de travail occupé sans examen.
En cas de conflits, conservez la réserve d’origine et la ligne de base actuelle disponibles. Une résolution de conflit est un nouveau travail qui nécessite une vérification, et non une preuve que les modifications originales ont été automatiquement renvoyées. Enregistrez toutes les sections reconstruites. Cela aide le réviseur à distinguer la source récupérée des décisions prises lors de l’intégration et empêche une fusion superficiellement propre de cacher un comportement perdu.
Considérez l’inspection d’objets comme une collecte de preuves
Un référentiel peut contenir des objets inaccessibles issus d’une activité ordinaire et qui n’ont rien à voir avec l’incident. Inspectez le contenu réel avant d’en sélectionner un. Un blob pendant peut conserver le texte sans son nom de fichier d’origine ou son contexte de projet. Un commit en suspens peut fournir un historique cohérent. Ces résultats ont une valeur pratique différente, alors étiquetez le résultat en fonction de ce que vous avez réellement trouvé.
Préservez le référentiel de preuves avant toute étape de maintenance ou de réparation. Séparez également les véritables erreurs d’intégrité des rapports informatifs sur les objets inaccessibles. L’exécution répétée d’opérations d’écriture jusqu’à ce que la sortie semble plus silencieuse peut supprimer du matériel de récupération utile sans restaurer la cible. Une enquête contrôlée en lecture seule fournit un chemin plus clair vers une référence de sauvetage vérifiée ou une récupération de source partielle limitée.
La survie des objets a des limites
Les entrées et objets Reflog ne constituent pas une archive illimitée. La rétention, la maintenance et les clones disponibles déterminent ce qui reste. Ne promettez pas le rétablissement uniquement parce que l’incident était récent. Inspectez rapidement la source pertinente et conservez-la. Si les objets requis sont absents partout où ils sont disponibles, un message de reflog ne peut à lui seul recréer leur contenu complet.
À ce stade, identifiez les sources alternatives telles que les clones survivants autorisés, les correctifs enregistrés, l’historique de l’éditeur ou les sauvegardes de fichiers indépendantes. Gardez la cible d’intégration explicite. Une implémentation reconstruite peut résoudre le problème de l’utilisateur tout en différant de la validation exacte perdue. Documentez cette distinction plutôt que de fabriquer une réclamation de recouvrement d’aspect historique à partir de preuves incomplètes.
Valider et conserver un résultat de sauvetage
Testez le comportement souhaité
Comparez la séquence récupérée avec les exigences réelles de la tâche. Inspectez les tests, la configuration et les actifs du projet associés. Exécutez ensuite une validation ciblée dans un environnement approprié. Un build réussi est utile mais ne peut pas exercer le comportement perdu. Examinez également toute résolution de conflit ou source reconstruite, car ce sont de nouvelles décisions superposées à l’historique récupéré.
Gardez la publication séparée de l’acceptation locale. Une branche de secours vérifiée n’a pas besoin de remplacer immédiatement l’historique distant partagé. Utilisez le workflow de révision et d’intégration autorisé normal du référentiel. Cela protège les travaux les plus récents des collègues et empêche la distribution de documents locaux inachevés ou sensibles simplement parce qu’une commande de récupération a réussi.
Gardez des points de récupération cohérents
Après acceptation, conservez une référence significative ou une autre sauvegarde de référentiel prise en charge et appropriée au flux de travail. Protégez également les actifs importants non-Git de manière indépendante. Testez une restauration représentative qui inclut l’état du projet dont vous avez réellement besoin. Une succursale distante, un reflog local et une copie complète des preuves offrent une couverture différente ; aucun ne doit être décrit comme une sauvegarde universelle de chaque frappe et fichier ignoré.
Documentez la source de secours acceptée et toutes les lacunes restantes. Conservez les preuves originales jusqu’à la fin de l’examen. Cela donne au futur chercheur suffisamment de contexte pour distinguer la séquence récupérée des modifications d’intégration ultérieures. Le résultat durable est un état de projet cohérent et testé avec une provenance compréhensible, plutôt qu’un ensemble d’identifiants d’objets que personne ne sait comment relier au travail prévu.
Quand PandaOffice Drecov peut vous aider
Une analyse du stockage peut s’avérer utile lorsque le répertoire du référentiel ou les fichiers sources sont véritablement absents du stockage local pris en charge. PandaOffice Drecov ne recrée pas le graphique de Git à partir de quelques fragments d’objets récupérés arbitrairement ni ne restaure l’historique supprimé d’un serveur distant. Vérifiez le soutien actuel et inspectez les candidats réels. Préférez les outils de récupération natifs de Git lorsque la base de données d’objets pertinente existe toujours et peut fournir un historique cohérent.
Étape 1 : sélectionnez le stockage réel du référentiel
Identifiez le disque qui contenait le répertoire de travail et les métadonnées Git pertinentes. Les arbres de travail liés peuvent placer les métadonnées ailleurs, alors préservez la relation. Évitez les nouvelles versions, les téléchargements de dépendances ou l’installation de logiciels de récupération sur le stockage affecté. Si l’appareil devient instable, arrêtez les analyses répétées et évaluez son état. Un clone sain sur un autre disque peut fournir une source plus cohérente qu’une récupération de stockage fragmenté.
Étape 2 : préserver le contexte complet du candidat
Ensuite, utilisez les filtres de chemin, de date, de nom et de format disponibles. Récupérez la structure de répertoires pertinente lorsque cela est possible plutôt que de sélectionner uniquement les fichiers sources visibles. Conservez également plusieurs copies plausibles du référentiel. Un dossier source peut être utile sans contenir l’historique local manquant, tandis que les fragments de métadonnées peuvent ne pas reconstruire un référentiel valide. Gardez ces limitations visibles et enregistrez l’origine de chaque candidat.
Étape 3 : récupérer ailleurs et inspecter via Git
Enregistrez les candidats sur un autre disque physique sain. Vérifiez les limitations des licences et des aperçus avant d’acheter. Inspectez ensuite les copies via Git et les outils sources appropriés sans exécuter automatiquement le code récupéré. Validez séparément la disponibilité des objets et le contenu du projet. L’utilitaire de stockage fournit des fichiers potentiels ; L’inspection Git détermine si un historique de validation cohérent survit et quels travaux doivent encore être reconstruits.
Ressources de récupération associées
Explorez les options de récupération pertinentes : Récupération du disque dur, Récupération de disque dur externe.
Pour un autre cas de récupération et ses vérifications pratiques, lire le guide de récupération associé.
Consultez les instructions du fournisseur pour la version installée : documentation officielle de récupération 1, documentation officielle de récupération 2, documentation officielle de récupération 3, documentation officielle de récupération 4.
