Je souhaite créer des sauvegardes Google Takeout régulières (par exemple, tous les trois mois) et les stocker sous forme cryptée dans un autre stockage en nuage tel que DropBox ou S3.

Il n’est pas nécessaire que ce soit une solution de nuage à nuage, bien que ce soit préférable. Il ne doit pas nécessairement être automatisé à 100%, mais plus il y en a, mieux c'est.

Merci d'avance pour vos idées.

Au lieu des API directes pour la sauvegarde de Google Takeout (ce qui semble presque impossible à faire pour le moment), vous pouvez sauvegarder vos données sur des solutions de stockage tierces via Google Drive. De nombreux services Google autorisent la sauvegarde sur Google Drive. Vous pouvez également sauvegarder Google Drive à l'aide des outils suivants:

GoogleCL - GoogleCL intègre les services Google à la ligne de commande.

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

FUSE Google Drive - Un système de fichiers FUSE en espace utilisateur 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. Cela utilise l’API GDrive, pas l’API GDocs, ce qui est intéressant. Pour l'utiliser, vous devez enregistrer une application Chrome. Il doit être au moins installable par vous, mais n'a pas besoin d'être publié. Vous pouvez utiliser comme point de départ une application standard dans le référentiel.

Exemple 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 tout fonctionne bien. Selon le niveau de contrôle souhaité, ce sera vraiment facile ou très complexe. C'est à toi de voir. Cela devrait être facile à faire à partir d’un serveur EC2 / S3. Il suffit de comprendre les commandes une par une pour tout ce dont vous avez besoin et de les insérer dans un script sur une tâche cron.

Si vous ne voulez pas travailler aussi dur, vous pouvez simplement utiliser un service tel que Spinbackup . Je suis sûr qu'il y en a d'autres aussi bons mais je n'en ai essayé aucun.

Ceci est une réponse partielle avec une automatisation partielle. Si Google décide de mettre un terme à l'accès automatisé à Google Takeout, il risque de ne plus fonctionner. Caractéristiques actuellement prises en charge dans cette réponse:

+ --------------------------------------------- + --- --------- + --------------------- +
| Fonction d'automatisation | Automatique? | Plateformes prises en charge |
+ --------------------------------------------- + --- --------- + --------------------- +
| Connexion au compte Google | Non | |
| Obtenir des cookies de Mozilla Firefox | Oui | Linux |
| Obtenir des cookies de Google Chrome | Oui | Linux, macOS |
| Demander la création d'archives | Non | |
| Calendrier de création d'archives | Kinda | Plats à emporter |
| Vérifier si l'archive est créée | Non | |
| Obtenir la liste des archives | Oui | Multiplateforme |
| Télécharger tous les fichiers d'archives | Oui | Linux, macOS |
| Chiffrer les fichiers d'archive téléchargés | Non | |
| Télécharger les fichiers d'archive téléchargés vers Dropbox | Non | |
| Téléchargez les fichiers d'archive téléchargés vers AWS S3 | Non | |
+ --------------------------------------------- + --- --------- + --------------------- +

Premièrement, une solution cloud à cloud ne peut pas vraiment fonctionner car il n'y a pas d'interface entre Google Takeout et les fournisseurs de stockage d'objets connus. Vous devez traiter les fichiers de sauvegarde sur votre propre ordinateur (qui peut être hébergé dans le cloud public, si vous le souhaitez) avant de les envoyer à votre fournisseur de stockage d'objets.

Deuxièmement, en l'absence d'API Google Takeout, un script d'automatisation doit prétendre être un utilisateur doté d'un navigateur pour parcourir la création et le flux de téléchargement de l'archive Google Takeout.

Fonctions d'automatisation

Connexion au compte Google

Ceci n'est pas encore automatisé. Le script doit prétendre être un navigateur et surmonter les obstacles possibles, tels que l'authentification à deux facteurs, les CAPTCHA et autres contrôles de sécurité renforcés.

Obtenir des cookies de Mozilla Firefox

J'ai un script pour les utilisateurs de Linux qui récupère les cookies de Google Takeout à partir de Mozilla Firefox et les exporte en tant que variables d'environnement. Pour que cela fonctionne, il ne doit y avoir qu'un seul profil Firefox, qui doit avoir visité https://takeout.google.com lors de la connexion.

En une ligne:

cookie_jar_path=$(mktemp) ; source_path=$(mktemp) ; cp ~/.mozilla/firefox/*.default/cookies.sqlite "$cookie_jar_path" ; sqlite3 "$cookie_jar_path" "SELECT name,value FROM moz_cookies WHERE baseDomain 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 script Bash plus joli:

#!/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.
# Only supports one Firefox profile.
# Edit the asterisk below to select a specific profile.
cp ~/.mozilla/firefox/*.default/cookies.sqlite "$cookie_jar_path"

# Get the cookies from the database
sqlite3 "$cookie_jar_path" \
       "SELECT name,value
        FROM moz_cookies
        WHERE baseDomain 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"

Obtenir des cookies de Google Chrome

J'ai un script pour Linux et éventuellement les utilisateurs de macOS qui récupère les cookies Google Takeout de Google Chrome et les exporte en tant que variables d'environnement. Le script part du principe que Python 3 venvest disponible et que le Defaultprofil Chrome a visité la page https://takeout.google.com lors de la connexion.

En une ligne:

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 script Bash plus joli:

#!/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"

Demander la création d'archives

Ceci n'est pas encore automatisé. Le script doit remplir le formulaire Google Takeout, puis l'envoyer.

Planification de la création d'archives

Il n'existe pas encore de moyen entièrement automatisé de le faire, mais en mai 2019, Google Takeout a introduit une fonctionnalité qui automatise la création d'une sauvegarde tous les 2 mois pendant 1 an (6 sauvegardes au total). Cela doit être fait dans le navigateur à l' adresse https://takeout.google.com tout en remplissant le formulaire de demande d'archive:

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

Ceci n'est pas encore automatisé. Si une archive a été créée, Google envoie parfois un courrier électronique à la boîte de réception Gmail de l'utilisateur, mais lors de 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 consiste à interroger Google Takeout régulièrement.

Obtenir la liste des archives

J'ai une commande pour le faire, en supposant que les cookies ont été définis en tant que variables d'environnement dans la section "Obtenir les 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 séparées par des lignes qui permettent de télécharger toutes les archives disponibles.
Il est analysé à partir de HTML avec regex .

Télécharger tous les fichiers d'archive

Voici le code dans Bash pour obtenir les URL des fichiers d'archive et les télécharger tous, en supposant que les cookies ont été définis en tant que variables d'environnement dans la section "Obtenir les 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 également être compatible avec macOS.

Explication de chaque partie:

1. curl commande avec 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 '(?<=")https://storage\.cloud\.google\.com/[^"]+(?=")' | \

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: il-P1 est possible de mettre en parallèle les téléchargements (passer à un nombre plus élevé), mais Google semble étrangler toutes les connexions sauf une.

   Remarque: -C - ignore les fichiers existants mais risque de ne pas pouvoir reprendre le téléchargement des fichiers existants.

Crypter les fichiers d'archives téléchargés

Ce n'est pas automatisé. L'implémentation dépend de la manière dont vous souhaitez chiffrer vos fichiers, et la consommation d'espace disque local doit être doublée pour chaque fichier que vous chiffrez.

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

Ceci n'est pas encore automatisé.

Téléchargez les fichiers d'archive téléchargés vers AWS S3

Ceci n’est pas encore automatisé, mais il devrait simplement consister à parcourir la liste des fichiers téléchargés et à exécuter une commande du type:

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

J'ai trouvé cette question en cherchant comment corriger mes photos Google qui n'apparaissaient pas correctement dans Google Drive (que je sauvegarde déjà automatiquement!).

Pour que vos photos s'affichent dans Google Drive, accédez à la page https://photos.google.com , Paramètres, et configurez-la pour afficher les photos dans un dossier du lecteur.

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