Il s'agit d'une réponse partielle avec une automatisation partielle. Elle peut cesser de fonctionner à l'avenir si Google décide de réprimer l'accès automatisé à Google Takeout. Fonctionnalités actuellement prises en charge dans cette réponse :

+---------------------------------------------+------------+---------------------+
|             Automation Feature              | Automated? | Supported Platforms |
+---------------------------------------------+------------+---------------------+
| Google Account log-in                       | No         |                     |
| Get cookies from Mozilla Firefox            | Yes        | Linux               |
| Get cookies from Google Chrome              | Yes        | Linux, macOS        |
| Request archive creation                    | No         |                     |
| Schedule archive creation                   | Kinda      | Takeout website     |
| Check if archive is created                 | No         |                     |
| Get archive list                            | Broken     | Cross-platform      |
| Download all archive files                  | Broken     | Linux, macOS        |
| Encrypt downloaded archive files            | No         |                     |
| Upload downloaded archive files to Dropbox  | No         |                     |
| Upload downloaded archive files to AWS S3   | No         |                     |
+---------------------------------------------+------------+---------------------+

Tout d'abord, une solution "cloud-to-cloud" ne peut pas vraiment fonctionner parce qu'il n'y a pas d'interface entre Google Takeout et un fournisseur connu de stockage d'objets. Vous devez traiter les fichiers de sauvegarde sur votre propre machine (qui pourrait être hébergée dans le nuage public, si vous le souhaitez) avant de les envoyer à votre fournisseur de stockage d'objets.

Deuxièmement, comme il n'existe pas d'API Google Takeout, un script d'automatisation doit se faire passer pour un utilisateur disposant d'un navigateur pour suivre le processus de création et de téléchargement de l'archive Google Takeout.

Caractéristiques de l'automatisation

Connexion au compte Google

Ce n'est pas encore automatisé. Le script devrait se faire passer pour un navigateur et surmonter d'éventuels obstacles tels que l'authentification à deux facteurs, les CAPTCHA et d'autres contrôles de sécurité renforcés.

Supprimer les cookies de Mozilla Firefox

J'ai un script pour les utilisateurs de Linux qui permet de récupérer les cookies de Google Takeout dans Mozilla Firefox et de les exporter en tant que variables d'environnement. Pour que cela fonctionne, le profil par défaut/actif doit avoir visité https://takeout.google.com tout en étant connecté.

En une phrase :

cookie_jar_path=$(mktemp) ; source_path=$(mktemp) ; firefox_profile=$(cat "$HOME/.mozilla/firefox/profiles.ini" | awk -v RS="" '{ if($1 ~ /^\[Install[0-9A-F]+\]/) { print } }' | sed -nr 's/^Default=(.*)$/\1/p' | head -1) ; cp "$HOME/.mozilla/firefox/$firefox_profile/cookies.sqlite" "$cookie_jar_path" ; sqlite3 "$cookie_jar_path" "SELECT name,value FROM moz_cookies WHERE host LIKE '%.google.com' AND (name LIKE 'SID' OR name LIKE 'HSID' OR name LIKE 'SSID' OR (name LIKE 'OSID' AND host LIKE 'takeout.google.com')) AND originAttributes LIKE '^userContextId=1' ORDER BY creationTime ASC;" | sed -e 's/|/=/' -e 's/^/export /' | tee "$source_path" ; source "$source_path" ; rm -f "$source_path" ; rm -f "$cookie_jar_path"

Comme un joli script de Bash :

#!/bin/bash
# Extract Google Takeout cookies from Mozilla Firefox and export them as envvars
#
# The browser must have visited https://takeout.google.com as an authenticated user.

# Warn the user if they didn't run the script with `source`
[[ "${BASH_SOURCE[0]}" == "${0}" ]] &&
       echo 'WARNING: You should source this script to ensure the resulting environment variables get set.'

cookie_jar_path=$(mktemp)
source_path=$(mktemp)

# In case the cookie database is locked, copy the database to a temporary file.
# Edit the $firefox_profile variable below to select a specific Firefox profile.
firefox_profile=$(
    cat "$HOME/.mozilla/firefox/profiles.ini" |
    awk -v RS="" '{
        if($1 ~ /^\[Install[0-9A-F]+\]/) {
            print
        }
    }' |
    sed -nr 's/^Default=(.*)$/\1/p' |
    head -1
)
cp "$HOME/.mozilla/firefox/$firefox_profile/cookies.sqlite" "$cookie_jar_path"

# Get the cookies from the database
sqlite3 "$cookie_jar_path" \
       "SELECT name,value
        FROM moz_cookies
        WHERE host LIKE '%.google.com'
        AND (
                name LIKE 'SID' OR
                name LIKE 'HSID' OR
                name LIKE 'SSID' OR
                (name LIKE 'OSID' AND host LIKE 'takeout.google.com')
        ) AND
        originAttributes LIKE '^userContextId=1'
        ORDER BY creationTime ASC;" |
                # Reformat the output into Bash exports
                sed -e 's/|/=/' -e 's/^/export /' |
                # Save the output into a temporary file
                tee "$source_path"

# Load the cookie values into environment variables
source "$source_path"

# Clean up
rm -f "$source_path"
rm -f "$cookie_jar_path"

Supprimer les cookies de Google Chrome

J'ai un script pour les utilisateurs de Linux et éventuellement de macOS pour récupérer les cookies Google Takeout de Google Chrome et les exporter en tant que variables d'environnement. Le script fonctionne en supposant que Python 3 venv est disponible et le Default Profil Chrome visité https://takeout.google.com tout en étant connecté.

En une phrase :

if [ ! -d "$venv_path" ] ; then venv_path=$(mktemp -d) ; fi ; if [ ! -f "${venv_path}/bin/activate" ] ; then python3 -m venv "$venv_path" ; fi ; source "${venv_path}/bin/activate" ; python3 -c 'import pycookiecheat, dbus' ; if [ $? -ne 0 ] ; then pip3 install git+https://github.com/n8henrie/pycookiecheat@dev dbus-python ; fi ; source_path=$(mktemp) ; python3 -c 'import pycookiecheat, json; cookies = pycookiecheat.chrome_cookies("https://takeout.google.com") ; [print("export %s=%s;" % (key, cookies[key])) for key in ["SID", "HSID", "SSID", "OSID"]]' | tee "$source_path" ; source "$source_path" ; rm -f "$source_path" ; deactivate

Comme un joli script de Bash :

#!/bin/bash
# Extract Google Takeout cookies from Google Chrome and export them as envvars
#
# The browser must have visited https://takeout.google.com as an authenticated user.

# Warn the user if they didn't run the script with `source`
[[ "${BASH_SOURCE[0]}" == "${0}" ]] &&
       echo 'WARNING: You should source this script to ensure the resulting environment variables get set.'

# Create a path for the Chrome cookie extraction library
if [ ! -d "$venv_path" ]
then
       venv_path=$(mktemp -d)
fi

# Create a Python 3 venv, if it doesn't already exist
if [ ! -f "${venv_path}/bin/activate" ]
then
        python3 -m venv "$venv_path"

fi

# Enter the Python virtual environment
source "${venv_path}/bin/activate"

# Install dependencies, if they are not already installed
python3 -c 'import pycookiecheat, dbus'
if [ $? -ne 0 ]
then
        pip3 install git+https://github.com/n8henrie/pycookiecheat@dev dbus-python
fi

# Get the cookies from the database
source_path=$(mktemp)
read -r -d '' code << EOL
import pycookiecheat, json
cookies = pycookiecheat.chrome_cookies("https://takeout.google.com")
for key in ["SID", "HSID", "SSID", "OSID"]:
        print("export %s=%s" % (key, cookies[key]))
EOL
python3 -c "$code" | tee "$source_path"

# Clean up
source "$source_path"
rm -f "$source_path"
deactivate
[[ "${BASH_SOURCE[0]}" == "${0}" ]] && rm -rf "$venv_path"

Nettoyer les fichiers téléchargés :

rm -rf "$venv_path"

Demande de création d'archives

Cette opération n'est pas encore automatisée. Le script devrait remplir le formulaire Google Takeout et le soumettre.

Planifier la création d'archives

Il n'existe pas encore de méthode entièrement automatisée, mais en mai 2019, Google Takeout a introduit une fonctionnalité qui automatise la création d'une sauvegarde tous les deux mois pendant un an (6 sauvegardes au total). Cette opération doit être effectuée dans le navigateur à l'adresse https://takeout.google.com en remplissant le formulaire de demande d'archives :

Vérifier si l'archive est créée

Cette opération n'est pas encore automatisée. Si une archive a été créée, Google envoie parfois un courriel à la boîte de réception Gmail de l'utilisateur, mais dans mes tests, cela ne se produit pas toujours pour des raisons inconnues.

Le seul autre moyen de vérifier si une archive a été créée est d'interroger régulièrement Google Takeout.

Obtenir la liste des archives

Cette section est actuellement interrompue.

Google a cessé de révéler les liens de téléchargement des archives sur la page de téléchargement de Takeout et a mis en place un jeton sécurisé qui limite à 5 fois la récupération du lien de téléchargement pour chaque archive.

J'ai une commande pour faire cela, en supposant que les cookies ont été définis comme variables d'environnement dans la section "Obtenir des cookies" ci-dessus :

~~curl -sL -H "Cookie: SID=${SID}; HSID=${HSID}; SSID=${SSID}; OSID=${OSID};" \ 'https://takeout.google.com/settings/takeout/downloads' | grep -Po '(?<=")https://storage.cloud.google.com/[^"]+(?=")' | awk '!x[$0]++'~~

~~Le résultat est une liste d'URL délimitée par des lignes qui conduisent au téléchargement de toutes les archives disponibles.
C'est analysé à partir de HTML avec une expression rationnelle .~~

Télécharger tous les fichiers d'archive

Cette section est actuellement interrompue.

Google a cessé de révéler les liens de téléchargement des archives sur la page de téléchargement de Takeout et a mis en place un jeton sécurisé qui limite à 5 fois la récupération du lien de téléchargement pour chaque archive.

Voici le code en Bash pour obtenir les URL des fichiers d'archive et les télécharger tous, en supposant que les cookies ont été définis comme variables d'environnement dans la section "Obtenir des cookies" ci-dessus :

~~curl -sL -H "Cookie: SID=${SID}; HSID=${HSID}; SSID=${SSID}; OSID=${OSID};" \ 'https://takeout.google.com/settings/takeout/downloads' | grep -Po '(?<=")https://storage.cloud.google.com/[^"]+(?=")' | awk '!x[$0]++' | xargs -n1 -P1 -I{} curl -LOJ -C - -H "Cookie: SID=${SID}; HSID=${HSID}; SSID=${SSID}; OSID=${OSID};" {}~~

Je l'ai testé sous Linux, mais la syntaxe devrait être compatible avec macOS également.

Explication de chaque partie :

1. curl avec des cookies d'authentification :

   ~~ curl -sL -H "Cookie: SID=${SID}; HSID=${HSID}; SSID=${SSID}; OSID=${OSID};" \~~

2. URL de la page contenant les liens de téléchargement

   ~~ 'https://takeout.google.com/settings/takeout/downloads' |~~

3. Le filtre ne correspond qu'aux liens de téléchargement

   grep -Po '(?

4. Filtrer les liens en double

   ~~ awk '!x[$0]++' |~~

5. Téléchargez chaque fichier de la liste, un par un :

   ~~ xargs -n1 -P1 -I{} curl -LOJ -C - -H "Cookie: SID=${SID}; HSID=${HSID}; SSID=${SSID}; OSID=${OSID};" {}~~

   Remarque : Paralléliser les téléchargements (modifier -P1 à un nombre plus élevé) est possible, mais Google semble étrangler toutes les connexions sauf une.

   Remarque : -C - ignore les fichiers qui existent déjà, mais il se peut qu'il ne parvienne pas à reprendre les téléchargements pour les fichiers existants.

Cryptage des fichiers d'archives téléchargés

Cette opération n'est pas automatisée. La mise en œuvre dépend de la manière dont vous souhaitez crypter vos fichiers, et la consommation d'espace disque local doit être doublée pour chaque fichier que vous cryptez.

Télécharger les fichiers d'archive téléchargés vers Dropbox

Cette opération n'est pas encore automatisée.

Télécharger les fichiers d'archive téléchargés sur AWS S3

Cette opération n'est pas encore automatisée, mais il devrait suffire de parcourir la liste des fichiers téléchargés et d'exécuter une commande comme :

aws s3 cp TAKEOUT_FILE "s3://MYBUCKET/Google Takeout/"

Google Takeout vous permet de programmer des exportations tous les deux mois, soit six par an. et jusqu'à un an. Vous pouvez choisir d'ajouter le fichier à un lecteur en nuage ou d'envoyer un lien de téléchargement. un lien de téléchargement par courriel (les téléchargements ne sont conservés qu'une semaine).

Pour le programmer, naviguez jusqu'à la page de https://takeout.google.com/settings/takeout?pli=1 .

Vous pouvez sélectionner les données Google à inclure dans la sauvegarde. Les lecteurs de cloud pris en charge sont : Drive, Dropbox, OneDrive et Box. Les formats de vidage sont Zip ou tgz.

Vous trouverez plus d'informations dans l'article Comment télécharger vos données Google .

Google Takeout ne fournissant pas d'API, l'automatisation du lancement d'un tel par le biais du navigateur risque de ne pas fonctionner lorsque l'interface utilisateur changera.

Il peut être préférable d'utiliser Google Takeout pour effectuer une sauvegarde sur un disque en nuage, et d'automatiser le téléchargement des nouveaux fichiers.

Vous pouvez consulter cette réponse pour trouver des moyens d'accéder à Google Drive pour la synchronisation. Il est probablement possible de faire correspondre Google Drive à Windows, de sorte que l'utilisation des tâches Windows pour synchroniser les nouvelles sauvegardes sur le disque local (bien que je n'aie pas essayé).

Au lieu d'utiliser les API directes pour sauvegarder Google Takeout (ce qui semble presque impossible à faire pour l'instant), vous pouvez sauvegarder vos données sur des solutions de stockage tierces via Google Drive. De nombreux services Google permettent la sauvegarde vers Google Drive, et vous pouvez sauvegarder Google Drive à l'aide des outils suivants :

GoogleCL - GoogleCL apporte les services Google à la ligne de commande.

gdatacopier - Utilitaires de gestion de documents en ligne de commande pour Google docs.

FUSE Google Drive - Un système de fichiers FUSE pour Google Drive, écrit en C.

Grive - Une implémentation open-source indépendante d'un client Google Drive. Il utilise l'API Google Document List pour communiquer avec les serveurs de Google. Le code est écrit en C++.

gdrive-cli - Une interface de ligne de commande pour GDrive. Elle utilise l'API GDrive et non l'API GDocs, ce qui est intéressant. Pour l'utiliser, vous devez enregistrer une application chrome. Celle-ci doit être au moins installable par vous, mais n'a pas besoin d'être publiée. Il y a une application standard dans le repo que vous pouvez utiliser comme point de départ.

Exemple de Python-fuse - Contient des diapositives et des exemples de systèmes de fichiers Python FUSE.

La plupart d'entre eux semblent se trouver dans les dépôts Ubuntu. J'ai moi-même utilisé Fuse, gdrive et GoogleCL et ils fonctionnent tous très bien. Selon le niveau de contrôle que vous souhaitez, ce sera très facile ou très complexe. C'est à vous de décider. Cela devrait être simple à faire à partir d'un serveur EC2/S3. Il suffit de trouver les commandes une par une pour tout ce dont vous avez besoin et de les mettre dans un script sur une tâche cron.

Si vous ne voulez pas travailler aussi dur, vous pouvez également utiliser un service tel que Spinbackup . Je suis sûr qu'il en existe d'autres tout aussi bons, mais je ne les ai pas essayés.

Du côté de Google, vous pouvez programmer l'exportation des plats à emporter tous les deux mois, ce qui la rendra automatique.

Une fois que vous avez téléchargé les données, la manière dont vous les traitez (par exemple en les téléchargeant vers un autre système de stockage en nuage) devrait être simple à automatiser. Il s'agit d'un sujet à part entière, qui dépend peut-être de ce que vous voulez. Il est donc préférable de poser des questions distinctes. Personnellement, j'extrais les données, je les mets dans un fichier Git Annexe repo et ensuite synchroniser ce repo sur n'importe quel autre média / stockage en nuage avec les fonctions fournies par Git Annex (il peut déjà faire tout cela). Une solution comme Git Annex a aussi l'avantage de dédupliquer les fichiers lorsque vous y mettez plusieurs Google takeouts.

La principale difficulté qui subsiste est la suivante comment automatiser le téléchargement des fichiers Google takeout . C'est particulièrement gênant s'il contient beaucoup de données, qui seraient réparties dans de nombreux fichiers (dans mon cas, plus de 350 fichiers individuels de 2 Go). C'est ce que je vais décrire maintenant :

C'est exactement ce que je suis en train de développer. Le code est ici sur GitHub (chrome-ext-google-takeout-downloader) .

Il s'agit d'une extension Google Chrome. (Ma première.) Actuellement, vous devez l'activer en mode développeur. C'est-à-dire que sur chrome://extensions/ vous activez "Developer mode", puis "Load unpacked", et ensuite vous sélectionnez le répertoire de l'extension.

Vous iriez sur le site web avec votre plat à emporter récent ( https://takeout.google.com/settings/takeout/downloads ), et lancer le téléchargement du premier fichier.

L'extension attendra ensuite la fin du téléchargement, puis lancera automatiquement le téléchargement de la partie suivante.

Pour que cela fonctionne, vous devez désactiver la fonction "Demander où enregistrer chaque fichier avant de le télécharger" et sélectionner un répertoire de téléchargement disposant de suffisamment d'espace.

Vous devez également autoriser le site web à télécharger plusieurs fichiers ("... téléchargements automatiques de plusieurs fichiers").

Malheureusement, Google vous demande de saisir à nouveau votre mot de passe Google toutes les 10 minutes environ. Vous pouvez également automatiser cette opération en enregistrant le mot de passe Google dans l'extension, qui le saisira alors automatiquement pour vous. Faites-le à vos risques et périls ! Lisez le code pour comprendre ce qui se passe avec le mot de passe.

En backup-google-takeout.py script est un exemple que vous exécuterez en arrière-plan avec l'option --poll-zip-dir qui ajoutera automatiquement le contenu des fichiers zip à une annexe Git.

Également en lien : Reddit : Google Takeout Archives - Télécharger TOUS les fichiers zip en même temps ? :

Cependant, si vous sélectionnez tgz ou tbz comme format d'archive au lieu de zip, les archives seront découpées en morceaux beaucoup plus gros (~50GB) et il y aura donc beaucoup moins à télécharger.

J'ai trouvé cette question en cherchant comment réparer mes photos google qui ne s'affichent pas correctement dans google drive (que je sauvegarde déjà automatiquement !).

Ainsi, pour que vos photos apparaissent dans google drive, allez sur https://photos.google.com , réglages et paramétrer l'affichage des photos dans un dossier du lecteur.

Ensuite, utilisez https://github.com/ncw/rclone pour cloner l'intégralité de votre disque dur Google (qui inclut désormais les photos en tant que répertoire "normal") sur votre espace de stockage local.