Come esportare tutte le raccolte in MongoDB?

Voglio esportare tutte le raccolte in MongoDB con il comando:

mongoexport -d dbname -o Mongo.json

Il risultato è:
nessuna raccolta specificata!

Il manuale dice che se non si specifica una raccolta, tutte le raccolte verranno esportate.
Tuttavia, perché non funziona?

http://docs.mongodb.org/manual/reference/mongoexport/#cmdoption-mongoexport--collection

La mia versione di MongoDB è 2.0.6.

Per le persone pigre, utilizzare mongodump, è più veloce:

mongodump -d <database_name> -o <directory_backup>

E per "ripristinarlo / importarlo" (da directory_backup / dump /):

mongorestore -d <database_name> <directory_backup>

In questo modo, non è necessario gestire tutte le raccolte singolarmente. Basta specificare il database.

Nota che consiglierei di non utilizzare mongodump/ mongorestoreper archivi di big data . È molto lento e una volta superati i 10/20 GB di dati possono essere necessarie ore per il ripristino.

Ho scritto questo script per Bash. Basta eseguirlo con 2 parametri (nome del database, dir per archiviare i file).

#!/bin/bash

if [ ! $1 ]; then
        echo " Example of use: $0 database_name [dir_to_store]"
        exit 1
fi
db=$1
out_dir=$2
if [ ! $out_dir ]; then
        out_dir="./"
else
        mkdir -p $out_dir
fi

tmp_file="fadlfhsdofheinwvw.js"
echo "print('_ ' + db.getCollectionNames())" > $tmp_file
cols=`mongo $db $tmp_file | grep '_' | awk '{print $2}' | tr ',' ' '`
for c in $cols
do
    mongoexport -d $db -c $c -o "$out_dir/exp_${db}_${c}.json"
done
rm $tmp_file

Seguire i passaggi seguenti per creare un mongodump dal server e importarlo in un altro server / computer locale che ha un nome utente e una password

1. mongodump -d dbname -o dumpname -u username -p password
2. scp -r user@remote:~/location/of/dumpname ./
3. mongorestore -d dbname dumpname/dbname/ -u username -p password

L'esportazione di tutte le raccolte tramite mongodump utilizza il comando seguente

mongodump -d database_name -o directory_to_store_dumps

Per ripristinare utilizzare questo comando

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Fateci sapere dove avete installato il vostro Mongo DB? (in Ubuntu o in Windows)

• Per Windows:

  1. Prima di esportare è necessario connettersi al proprio Mongo DB nel prompt cmd e assicurarsi di essere in grado di connettersi all'host locale.
  2. Ora apri un nuovo prompt cmd ed esegui il comando seguente,

  mongodump --db nome database --out percorso da salvare
  ad es .: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Visita https://www.youtube.com/watch?v=hOCp3Jv6yKo per maggiori dettagli.

• Per Ubuntu:

  1. Accedi al tuo terminale in cui è installato Mongo DB e assicurati di essere in grado di collegarti al tuo Mongo DB.
  2. Ora apri un nuovo terminale ed esegui il comando seguente,

  mongodump -d nome database -o nome file da salvare,
  ad es .: mongodump -d mydb -o output.json

  3. Visita https://www.youtube.com/watch?v=5Fwd2ZB86gg per maggiori dettagli.

Le risposte precedenti lo hanno spiegato bene, sto aggiungendo la mia risposta per aiutare nel caso in cui tu abbia a che fare con un database remoto protetto da password

mongodump --host xx.xxx.xx.xx --port 27017 --db your_db_name --username your_user_name --password your_password --out /target/folder/path

Nel caso in cui si desideri connettere un server mongoDB remoto come mongolab.com, è necessario passare le credenziali di connessione, ad es.

mongoexport -h id.mongolab.com:60599 -u username -p password -d mydb -c mycollection -o mybackup.json

Se stai bene con il formato bson, puoi usare l'utility mongodump con lo stesso flag -d. Dump di tutte le raccolte nella directory di dump (impostazione predefinita, può essere modificata tramite l'opzione -o) nel formato bson. È quindi possibile importare questi file utilizzando l'utilità mongorestore.

È possibile utilizzare mongo --eval 'printjson(db.getCollectionNames())'per ottenere l'elenco delle raccolte e quindi eseguire un mongoexport su tutte. Ecco un esempio in rubino

  out = `mongo  #{DB_HOST}/#{DB_NAME} --eval "printjson(db.getCollectionNames())"`

  collections = out.scan(/\".+\"/).map { |s| s.gsub('"', '') }

  collections.each do |collection|
    system "mongoexport --db #{DB_NAME}  --collection #{collection}  --host '#{DB_HOST}' --out #{collection}_dump"
  end

Avevo bisogno della versione dello script batch di Windows. Questa discussione è stata utile, quindi ho pensato di contribuire anche con la mia risposta.

mongo "{YOUR SERVER}/{YOUR DATABASE}" --eval "rs.slaveOk();db.getCollectionNames()" --quiet>__collections.txt
for /f %%a in ('type __collections.txt') do @set COLLECTIONS=%%a
for %%a in (%COLLECTIONS%) do mongoexport --host {YOUR SERVER} --db {YOUR DATABASE} --collection %%a --out data\%%a.json
del __collections.txt

Ho avuto alcuni problemi con l'utilizzo set /p COLLECTIONS=<__collections.txt, quindi il for /fmetodo contorto .

Ho scoperto dopo aver provato molti esempi contorti che un approccio molto semplice ha funzionato per me.

Volevo solo prendere un dump di un db da locale e importarlo su un'istanza remota:

sulla macchina locale:

mongodump -d databasename

poi ho mandato il mio dump sulla mia macchina server:

scp -r dump user@xx.xxx.xxx.xxx:~

quindi dalla directory principale del dump semplicemente:

mongorestore 

e che ha importato il database.

supponendo che il servizio mongodb stia funzionando ovviamente.

Se lo desideri, puoi esportare tutte le raccolte in CSV senza specificare --fields(verranno esportati tutti i campi).

Da http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ eseguire questo script bash

OIFS=$IFS;
IFS=",";

# fill in your details here
dbname=DBNAME
user=USERNAME
pass=PASSWORD
host=HOSTNAME:PORT

# first get all collections in the database
collections=`mongo "$host/$dbname" -u $user -p $pass --eval "rs.slaveOk();db.getCollectionNames();"`;
collections=`mongo $dbname --eval "rs.slaveOk();db.getCollectionNames();"`;
collectionArray=($collections);

# for each collection
for ((i=0; i<${#collectionArray[@]}; ++i));
do
    echo 'exporting collection' ${collectionArray[$i]}
    # get comma separated list of keys. do this by peeking into the first document in the collection and get his set of keys
    keys=`mongo "$host/$dbname" -u $user -p $pass --eval "rs.slaveOk();var keys = []; for(var key in db.${collectionArray[$i]}.find().sort({_id: -1}).limit(1)[0]) { keys.push(key); }; keys;" --quiet`;
    # now use mongoexport with the set of keys to export the collection to csv
    mongoexport --host $host -u $user -p $pass -d $dbname -c ${collectionArray[$i]} --fields "$keys" --csv --out $dbname.${collectionArray[$i]}.csv;
done

IFS=$OIFS;

Puoi farlo usando il comando mongodump

Passaggio 1: aprire il prompt dei comandi

Passaggio 2: vai alla cartella bin dell'installazione di mongoDB (C: \ Programmi \ MongoDB \ Server \ 4.0 \ bin)

Passaggio 3: quindi eseguire il comando seguente

mongodump -d your_db_name -o destination_path

nome_db = test

destination_path = C: \ Users \ HP \ Desktop

I file esportati verranno creati nella cartella destination_path \ your_db_name (in questo esempio C: \ Users \ HP \ Desktop \ test)

Riferimenti: o7planning

Se si desidera eseguire il dump di tutte le raccolte in tutti i database (che è un'interpretazione espansiva dell'intento del richiedente originale), utilizzare

mongodump

Tutti i database e le raccolte verranno creati in una directory denominata "dump" nella posizione "corrente"

Mi rendo conto che questa è una domanda piuttosto vecchia e che mongodump / mongorestore è chiaramente il modo giusto se si desidera un risultato fedele al 100%, compresi gli indici.

Tuttavia, avevo bisogno di una soluzione rapida e sporca che sarebbe probabilmente compatibile con le versioni precedenti e nuove di MongoDB, a condizione che non ci fosse nulla di particolarmente strano. E per questo volevo la risposta alla domanda originale.

Esistono altre soluzioni accettabili sopra, ma questa pipeline Unix è relativamente breve e dolce:

mongo --quiet mydatabase --eval "db.getCollectionNames().join('\n')" | \
grep -v system.indexes | \
xargs -L 1 -I {} mongoexport -d mydatabase -c {} --out {}.json

Questo produce un .jsonfile con un nome appropriato per ogni raccolta.

Si noti che il nome del database ("mydatabase") appare due volte. Suppongo che il database sia locale e non sia necessario passare credenziali, ma è facile farlo con entrambi mongoe mongoexport.

Nota che sto usando grep -vper scartare system.indexes, perché non voglio che una versione precedente di MongoDB tenti di interpretare una raccolta di sistema da una più recente. Invece sto permettendo alla mia applicazione di fare le sue solite ensureIndexchiamate per ricreare gli indici.

puoi creare il file zip usando il seguente comando. Creerà il file zip del database {dbname} fornito. Successivamente potrai importare il seguente file zip nel tuo mongo DB.

Window filepath=C:\Users\Username\mongo 

mongodump --archive={filepath}\+{filename}.gz --gzip --db {dbname}

Ecco cosa ha funzionato per me durante il ripristino di un database esportato:

mongorestore -d 0 ./0 --drop

dove ./conteneva i file bson esportati. Si noti che --dropsovrascriverà i dati esistenti.

se si desidera utilizzare mongoexport e mongoimport per esportare / importare ogni collezione dal database, credo che questa utility può essere utile per voi. Ho usato un'utilità simile un paio di volte;

LOADING=false

usage()
{
    cat << EOF
    usage: $0 [options] dbname

    OPTIONS:
        -h      Show this help.
        -l      Load instead of export
        -u      Mongo username
        -p      Mongo password
        -H      Mongo host string (ex. localhost:27017)
EOF
}

while getopts "hlu:p:H:" opt; do
    MAXOPTIND=$OPTIND

    case $opt in 
        h)
            usage
            exit
            ;;
        l)
            LOADING=true
            ;;
        u)
            USERNAME="$OPTARG"
            ;;
        p) 
            PASSWORD="$OPTARG"
            ;;
        H)
            HOST="$OPTARG"
            ;;
        \?)
            echo "Invalid option $opt"
            exit 1
            ;;
    esac
done

shift $(($MAXOPTIND-1))

if [ -z "$1" ]; then
    echo "Usage: export-mongo [opts] <dbname>"
    exit 1
fi

DB="$1"
if [ -z "$HOST" ]; then
    CONN="localhost:27017/$DB"
else
    CONN="$HOST/$DB"
fi

ARGS=""
if [ -n "$USERNAME" ]; then
    ARGS="-u $USERNAME"
fi
if [ -n "$PASSWORD" ]; then
    ARGS="$ARGS -p $PASSWORD"
fi

echo "*************************** Mongo Export ************************"
echo "**** Host:      $HOST"
echo "**** Database:  $DB"
echo "**** Username:  $USERNAME"
echo "**** Password:  $PASSWORD"
echo "**** Loading:   $LOADING"
echo "*****************************************************************"

if $LOADING ; then
    echo "Loading into $CONN"
    tar -xzf $DB.tar.gz
    pushd $DB >/dev/null

    for path in *.json; do
        collection=${path%.json}
        echo "Loading into $DB/$collection from $path"
        mongoimport $ARGS -d $DB -c $collection $path
    done

    popd >/dev/null
    rm -rf $DB
else
    DATABASE_COLLECTIONS=$(mongo $CONN $ARGS --quiet --eval 'db.getCollectionNames()' | sed 's/,/ /g')

    mkdir /tmp/$DB
    pushd /tmp/$DB 2>/dev/null

    for collection in $DATABASE_COLLECTIONS; do
        mongoexport --host $HOST -u $USERNAME -p $PASSWORD -db $DB -c $collection --jsonArray -o $collection.json >/dev/null
    done

    pushd /tmp 2>/dev/null
    tar -czf "$DB.tar.gz" $DB 2>/dev/null
    popd 2>/dev/null
    popd 2>/dev/null
    mv /tmp/$DB.tar.gz ./ 2>/dev/null
    rm -rf /tmp/$DB 2>/dev/null
fi

Se si desidera eseguire il backup di tutti i dbs sul server, senza preoccuparsi che vengano chiamati i dbs, utilizzare il seguente script shell:

#!/bin/sh

md=`which mongodump`
pidof=`which pidof`
mdi=`$pidof mongod`
dir='/var/backup/mongo'

if [ ! -z "$mdi" ]
   then
        if [ ! -d "$dir" ]
           then
               mkdir -p $dir
           fi
        $md --out $dir >/dev/null 2>&1
   fi

Questo utilizza l'utilità mongodump, che eseguirà il backup di tutti i DB se non ne viene specificato nessuno.

Puoi metterlo nel tuo cronjob e funzionerà solo se il processo mongod è in esecuzione. Creerà anche la directory di backup se non esiste.

Ogni backup del DB viene scritto in una singola directory, quindi è possibile ripristinare singoli DB dal dump globale.

Per prima cosa, di Start the Mongo DB - per quello vai al percorso come ->

C: \ Programmi \ MongoDB \ Server \ 3.2 \ bin e fare clic sul file mongod.exe per avviare il server MongoDB.

Comando in Windows per esportare

• Comando per esportare il database MongoDB in Windows da "server remoto" al computer locale nella directory C: / Users / Desktop / cartella temporanea dal server remoto con l'indirizzo IP e la porta interni.

C:> mongodump --host remote_ip_address: 27017 --db -o C: / Users / Desktop / temp-folder

Comando in Windows da importare

• Comando per importare il database MongoDB in Windows nel "server remoto" dalla directory del computer locale C: / Users / Desktop / temp-folder / db-dir

C:> mongorestore --host = ip --port = 27017 -d C: / Users / Desktop / temp-folder / db-dir

#mongodump using sh script 
#!/bin/bash
TIMESTAMP=`date +%F-%H%M`
APP_NAME="folder_name"
BACKUPS_DIR="/xxxx/tst_file_bcup/$APP_NAME"
BACKUP_NAME="$APP_NAME-$TIMESTAMP"
/usr/bin/mongodump -h 127.0.0.1 -d <dbname> -o $BACKUPS_DIR/$APP_NAME/$BACKUP_NAME
tar -zcvf $BACKUPS_DIR/$BACKUP_NAME.tgz $BACKUPS_DIR/$APP_NAME/$BACKUP_NAME
rm -rf /home/wowza_analytics_bcup/wowza_analytics/wowza_analytics
### 7 days old backup delete automaticaly using given command

find /home/wowza_analytics_bcup/wowza_analytics/ -mindepth 1 -mtime +7 -delete

1. Apri la connessione
2. Avvia il server
3. apri il nuovo prompt dei comandi

Esportare:

mongo/bin> mongoexport -d webmitta -c domain -o domain-k.json

Importare:

mongoimport -d dbname -c newCollecionname --file domain-k.json

Dove

webmitta(db name)
domain(Collection Name)
domain-k.json(output file name)

Esistono più opzioni a seconda di ciò che si desidera fare

1) Se si desidera esportare il database in un altro database mongo, è necessario utilizzare mongodump. Questo crea una cartella di file BSON che hanno metadati che JSON non avrebbe.

mongodump
mongorestore --host mongodb1.example.net --port 37017 dump/

2) Se vuoi esportare il tuo database in JSON puoi usarlo mongoexporttranne che devi farlo una raccolta alla volta (questo è di progettazione). Tuttavia, penso che sia più semplice esportare l'intero database con mongodumpe poi convertirlo in JSON.

# -d is a valid option for both mongorestore and mongodump

mongodump -d <DATABASE_NAME>
for file in dump/*/*.bson; do bsondump $file > $file.json; done

Per il dump, il tuo DB è incolto nella CMD sottostante

   mongodump -d <your d name> -o <dump path>
Ex:mongodump -d qualetics -o D:\dbpackup\qualetics

Per esportare in formato JSON, fai ciò seguendo i comandi che puoi vedere.

mongoexport --db dbname --collection collectionName --out directoryPATH/JSONfileName.json