Vorrei creare backup regolari di Google Takeout (diciamo ogni 3 mesi) e archiviarli crittografati in altri cloud storage come DropBox o S3.

Non deve essere una soluzione cloud-to-cloud, sebbene preferita. Non deve essere automatizzato al 100%, tuttavia, tanto più meglio è.

Grazie in anticipo per eventuali idee.

Invece delle API dirette per il backup di Google Takeout (che al momento sembra quasi impossibile da eseguire), è possibile eseguire il backup dei dati su soluzioni di archiviazione di terze parti tramite Google Drive. Molti servizi Google consentono il backup su Google Drive e puoi eseguire il backup di Google Drive utilizzando i seguenti strumenti:

GoogleCL - GoogleCL porta i servizi di Google alla riga di comando.

gdatacopier - Utilità di gestione dei documenti della riga di comando per i documenti di Google.

FUSE Google Drive - Un file system FUSE per lo spazio utente per Google Drive, scritto in C.

Grive : un'implementazione open source indipendente di un client Google Drive. Utilizza l'API dell'elenco documenti di Google per comunicare con i server di Google. Il codice è scritto in C ++.

GDrive-cli - Un'interfaccia a riga di comando per GDrive. Questo utilizza l'API GDrive, non l'API GDocs, il che è interessante. Per usarlo, è necessario registrare un'applicazione Chrome. Deve essere almeno installabile da te, ma non deve essere pubblicato. Nel repository è presente un'app boilerplate che è possibile utilizzare come punto di partenza.

Esempio di python-fuse : contiene alcune diapositive ed esempi di filesystem Python FUSE.

Molti di questi sembrano essere nei repository di Ubuntu. Ho usato me stesso Fuse, gdrive e GoogleCL e funzionano tutti bene. A seconda del livello di controllo desiderato, questo sarà davvero semplice o molto complesso. Dipende da te. Dovrebbe essere semplice farlo da un server EC2 / S3. Basta capire i comandi uno per uno per tutto ciò di cui hai bisogno e metterlo in uno script su un lavoro cron.

Se non vuoi lavorare così duramente, puoi anche usare un servizio come Spinbackup . Sono sicuro che ce ne sono altri altrettanto buoni ma non ne ho provato nessuno.

Questa è una risposta parziale con automazione parziale. In futuro potrebbe smettere di funzionare se Google decide di reprimere l'accesso automatico a Google Takeout. Funzionalità attualmente supportate in questa risposta:

+ --------------------------------------------- + --- --------- + --------------------- +
| Funzione di automazione | Automatizzata? | Piattaforme supportate |
+ --------------------------------------------- + --- --------- + --------------------- +
| Accesso all'account Google | No | |
| Ricevi i cookie da Mozilla Firefox | Sì | Linux |
| Ricevi cookie da Google Chrome | Sì | Linux, macOS |
| Richiedi creazione archivio | No | |
| Pianifica la creazione dell'archivio | Kinda | Sito Web da asporto |
| Controlla se l'archivio è stato creato | No | |
| Ottieni l'elenco degli archivi | Sì | Multipiattaforma |
| Scarica tutti i file di archivio | Sì | Linux, macOS |
| Crittografa i file di archivio scaricati | No | |
| Carica file di archivio scaricati su Dropbox | No | |
| Carica file di archivio scaricati su AWS S3 | No | |
+ --------------------------------------------- + --- --------- + --------------------- +

In primo luogo, una soluzione cloud-to-cloud non può davvero funzionare perché non esiste un'interfaccia tra Google Takeout e qualsiasi provider di archiviazione oggetti noto. Devi elaborare i file di backup sul tuo computer (che potrebbe essere ospitato nel cloud pubblico, se lo desideri) prima di inviarli al tuo provider di archiviazione oggetti.

In secondo luogo, poiché non esiste un'API di Google Takeout, uno script di automazione deve fingere di essere un utente con un browser per seguire la creazione dell'archivio di Google Takeout e il flusso di download.

Funzioni di automazione

Accesso all'account Google

Questo non è ancora automatizzato. Lo script dovrebbe fingere di essere un browser e navigare possibili ostacoli come l'autenticazione a due fattori, CAPTCHA e altri controlli di sicurezza aumentati.

Ricevi i cookie da Mozilla Firefox

Ho uno script per gli utenti Linux per prendere i cookie di Google Takeout da Mozilla Firefox ed esportarli come variabili di ambiente. Perché ciò funzioni, dovrebbe esserci solo un profilo Firefox e il profilo deve aver visitato https://takeout.google.com durante l'accesso.

Come una linea:

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"

Come uno script Bash più bello:

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

Ricevi cookie da Google Chrome

Ho uno script per utenti Linux e possibilmente macOS per acquisire i cookie di Google Takeout da Google Chrome ed esportarli come variabili di ambiente. Lo script funziona presupponendo che Python 3 venvsia disponibile e che il Defaultprofilo Chrome abbia visitato https://takeout.google.com durante l'accesso.

Come una linea:

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

Come uno script Bash più bello:

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

Pulisci i file scaricati:

rm -rf "$venv_path"

Richiedi la creazione dell'archivio

Questo non è ancora automatizzato. Lo script dovrebbe compilare il modulo di Google Takeout e quindi inviarlo.

Pianifica la creazione dell'archivio

Non esiste ancora un modo completamente automatizzato per farlo, ma a maggio 2019, Google Takeout ha introdotto una funzione che automatizza la creazione di 1 backup ogni 2 mesi per 1 anno (6 backup in totale). Questo deve essere fatto nel browser all'indirizzo https://takeout.google.com durante la compilazione del modulo di richiesta di archiviazione:

Controlla se l'archivio è stato creato

Questo non è ancora automatizzato. Se è stato creato un archivio, Google a volte invia un'e-mail alla posta in arrivo di Gmail dell'utente, ma nei miei test, ciò non sempre accade per motivi sconosciuti.

L'unico altro modo per verificare se è stato creato un archivio è il polling periodico di Google Takeout.

Ottieni l'elenco degli archivi

Ho un comando per farlo, supponendo che i cookie siano stati impostati come variabili di ambiente nella sezione "Ottieni cookie" sopra:

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]++'

L'output è un elenco delimitato da righe di URL che porta a download di tutti gli archivi disponibili.
E ' analizzato da HTML con regex .

Scarica tutti i file di archivio

Ecco il codice in Bash per ottenere gli URL dei file di archivio e scaricarli tutti, supponendo che i cookie siano stati impostati come variabili di ambiente nella sezione "Ottieni cookie" sopra:

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};" {}

L'ho provato su Linux, ma anche la sintassi dovrebbe essere compatibile con macOS.

Spiegazione di ogni parte:

1. curl comando con cookie di autenticazione:

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

2. URL della pagina che contiene i collegamenti per il download

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

3. Il filtro corrisponde solo ai collegamenti di download

   grep -Po '(?<=")https://storage\.cloud\.google\.com/[^"]+(?=")' | \

4. Filtra i collegamenti duplicati

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

5. Scarica tutti i file nell'elenco, uno per uno:

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

   Nota: è possibile parallelizzare i download (passando -P1a un numero più alto), ma Google sembra limitare tutte le connessioni tranne una.

   Nota: -C - salta i file già esistenti, ma potrebbe non riprendere correttamente i download per i file esistenti.

Crittografa i file di archivio scaricati

Questo non è automatizzato. L'implementazione dipende da come ti piace crittografare i tuoi file e il consumo di spazio su disco locale deve essere raddoppiato per ogni file che stai crittografando.

Carica i file di archivio scaricati su Dropbox

Questo non è ancora automatizzato.

Carica i file di archivio scaricati su AWS S3

Questo non è ancora automatizzato, ma dovrebbe semplicemente trattarsi di scorrere l'elenco dei file scaricati ed eseguire un comando come:

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

Ho trovato questa domanda durante la ricerca di come correggere le mie foto di Google che non vengono visualizzate correttamente in Google Drive (di cui sto già eseguendo automaticamente il backup!).

Quindi, per visualizzare le tue foto su Google Drive, vai su https://photos.google.com , le impostazioni e impostale per mostrare le foto in una cartella in unità.

Quindi utilizzare https://github.com/ncw/rclone per clonare l'intera unità di Google (che ora include le foto come directory "normale") fino alla memoria locale.