Wie exportiere ich alle Sammlungen in MongoDB?

Ich möchte alle Sammlungen in MongoDB mit dem folgenden Befehl exportieren:

mongoexport -d dbname -o Mongo.json

Das Ergebnis ist:
Keine Sammlung angegeben!

Das Handbuch besagt, dass alle Sammlungen exportiert werden, wenn Sie keine Sammlung angeben.
Warum funktioniert das jedoch nicht?

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

Meine MongoDB-Version ist 2.0.6.

Für faule Leute mongodumpist es schneller:

mongodump -d <database_name> -o <directory_backup>

Und um es "wiederherzustellen / importieren" (aus directory_backup / dump /):

mongorestore -d <database_name> <directory_backup>

Auf diese Weise müssen Sie nicht alle Sammlungen einzeln bearbeiten. Geben Sie einfach die Datenbank an.

Beachten Sie, dass ich die Verwendung von mongodump/ mongorestorefür Big-Data-Speicher empfehlen würde . Es ist sehr langsam und sobald Sie 10 / 20GB Daten erreicht haben, kann die Wiederherstellung Stunden dauern.

Ich habe dafür ein Bash-Skript geschrieben. Führen Sie es einfach mit 2 Parametern aus (Datenbankname, Verzeichnis zum Speichern von Dateien).

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

Führen Sie die folgenden Schritte aus, um einen Mongodump vom Server zu erstellen und einen anderen Server / lokalen Computer mit einem Benutzernamen und einem Kennwort zu importieren

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

Exportieren Sie alle Sammlungen mit Mongodump mit dem folgenden Befehl

mongodump -d database_name -o directory_to_store_dumps

Verwenden Sie zum Wiederherstellen diesen Befehl

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Bitte teilen Sie uns mit, wo Sie Ihre Mongo DB installiert haben. (entweder in Ubuntu oder in Windows)

• Für Windows:

  1. Vor dem Exportieren müssen Sie in der Eingabeaufforderung cmd eine Verbindung zu Ihrer Mongo-Datenbank herstellen und sicherstellen, dass Sie eine Verbindung zu Ihrem lokalen Host herstellen können.
  2. Öffnen Sie nun eine neue cmd-Eingabeaufforderung und führen Sie den folgenden Befehl aus:

  mongodump --db Datenbankname --out Pfad zum Speichern
  zB: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Besuchen Sie https://www.youtube.com/watch?v=hOCp3Jv6yKo für weitere Details.

• Für Ubuntu:

  1. Melden Sie sich bei Ihrem Terminal an, auf dem Mongo DB installiert ist, und stellen Sie sicher, dass Sie eine Verbindung zu Ihrer Mongo DB herstellen können.
  2. Öffnen Sie nun ein neues Terminal und führen Sie den folgenden Befehl aus:

  mongodump -d Datenbankname -o zu speichernder Dateiname
  zB: mongodump -d mydb -o output.json

  3. Besuchen Sie https://www.youtube.com/watch?v=5Fwd2ZB86gg für weitere Details.

Frühere Antworten haben es gut erklärt. Ich füge meine Antwort hinzu, um Ihnen zu helfen, falls Sie mit einer passwortgeschützten Remote-Datenbank arbeiten

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

Wenn Sie einen Remote-MongoDB-Server wie mongolab.com verbinden möchten, sollten Sie die Anmeldeinformationen für die Verbindung übergeben, z.

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

Wenn Sie mit dem bson-Format einverstanden sind, können Sie das Dienstprogramm mongodump mit demselben Flag -d verwenden. Alle Sammlungen werden im bson-Format in das Speicherauszugsverzeichnis (die Standardeinstellung kann über die Option -o geändert werden) ausgegeben. Sie können diese Dateien dann mit dem Dienstprogramm mongorestore importieren.

Sie können verwenden mongo --eval 'printjson(db.getCollectionNames())', um die Liste der Sammlungen abzurufen und dann einen Mongoexport für alle Sammlungen durchzuführen. Hier ist ein Beispiel in Rubin

  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

Ich brauchte die Windows-Batch-Skriptversion. Dieser Thread war nützlich, also dachte ich, ich würde auch meine Antwort dazu beitragen.

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

Ich hatte einige Probleme bei der Verwendung set /p COLLECTIONS=<__collections.txt, daher die verschlungene for /fMethode.

Nachdem ich viele verschlungene Beispiele ausprobiert hatte, stellte ich fest, dass ein sehr einfacher Ansatz für mich funktionierte.

Ich wollte nur einen Speicherauszug einer Datenbank von local nehmen und auf eine Remote-Instanz importieren:

auf dem lokalen Computer:

mongodump -d databasename

dann habe ich meinen Dump auf meinen Server übertragen:

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

dann aus dem übergeordneten Verzeichnis des Dumps einfach:

mongorestore 

und das importierte die Datenbank.

vorausgesetzt, der Mongodb-Dienst läuft natürlich.

Wenn Sie möchten, können Sie alle Sammlungen ohne Angabe von CSV --fieldsexportieren (exportiert alle Felder).

Von http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ diesen Bash - Skript ausführen

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;

Wenn Sie alle Sammlungen in allen Datenbanken sichern möchten (was eine weitreichende Interpretation der Absicht des ursprünglichen Fragestellers darstellt), verwenden Sie

mongodump

Alle Datenbanken und Sammlungen werden in einem Verzeichnis namens "dump" am "aktuellen" Speicherort erstellt

Sie können dies mit dem Befehl mongodump tun

Schritt 1: Öffnen Sie die Eingabeaufforderung

Schritt 2: Wechseln Sie zum Ordner bin Ihrer mongoDB-Installation (C: \ Programme \ MongoDB \ Server \ 4.0 \ bin).

Schritt 3: Führen Sie dann den folgenden Befehl aus

mongodump -d your_db_name -o destination_path

your_db_name = test

Zielpfad = C: \ Benutzer \ HP \ Desktop

Exportierte Dateien werden im Ordner Zielpfad \ Ihr_Datenbankname erstellt (in diesem Beispiel C: \ Benutzer \ HP \ Desktop \ Test).

Referenzen: o7planning

Mir ist klar, dass dies eine ziemlich alte Frage ist und dass Mongodump / Mongorestore eindeutig der richtige Weg ist, wenn Sie ein 100% originalgetreues Ergebnis erzielen möchten, einschließlich Indizes.

Ich brauchte jedoch eine schnelle und schmutzige Lösung, die wahrscheinlich vorwärts- und rückwärtskompatibel zwischen alten und neuen Versionen von MongoDB ist, vorausgesetzt, es ist nichts besonders Verrücktes los. Und dafür wollte ich die Antwort auf die ursprüngliche Frage.

Es gibt andere akzeptable Lösungen, aber diese Unix-Pipeline ist relativ kurz und süß:

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

Dadurch wird .jsonfür jede Sammlung eine entsprechend benannte Datei erstellt.

Beachten Sie, dass der Datenbankname ("mydatabase") zweimal angezeigt wird. Ich gehe davon aus, dass die Datenbank lokal ist und Sie keine Anmeldeinformationen übergeben müssen, aber das ist mit beiden mongound einfach mongoexport.

Beachten Sie, dass ich grep -vzum Verwerfen verwende system.indexes, da ich nicht möchte, dass eine ältere Version von MongoDB versucht, eine Systemsammlung aus einer neueren zu interpretieren. Stattdessen erlaube ich meiner Anwendung, ihre üblichen ensureIndexAufrufe durchzuführen, um die Indizes neu zu erstellen.

Sie können eine Zip-Datei mit dem folgenden Befehl erstellen. Es wird eine Zip-Datei der bereitgestellten Datenbank {Datenbankname} erstellt. Sie können die folgende Zip-Datei später in Ihre Mongo-Datenbank importieren.

Window filepath=C:\Users\Username\mongo 

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

Folgendes hat bei der Wiederherstellung einer exportierten Datenbank funktioniert:

mongorestore -d 0 ./0 --drop

Dabei enthielt ./ die exportierten Bson-Dateien. Beachten Sie, dass das --dropvorhandene Daten überschreibt.

Wenn Sie mongoexport und mongoimport verwenden möchten , um jede Sammlung aus der Datenbank zu exportieren / importieren, kann dieses Dienstprogramm für Sie hilfreich sein. Ich habe ein paar Mal ein ähnliches Dienstprogramm verwendet.

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

Wenn Sie alle Datenbankdatenbanken auf dem Server sichern möchten, ohne sich Sorgen machen zu müssen, dass die Datenbankdatenbanken aufgerufen werden, verwenden Sie das folgende Shell-Skript:

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

Hierbei wird das Dienstprogramm mongodump verwendet, mit dem alle DBs gesichert werden, wenn keine angegeben ist.

Sie können dies in Ihren Cronjob einfügen, und es wird nur ausgeführt, wenn der Mongod-Prozess ausgeführt wird. Es wird auch das Sicherungsverzeichnis erstellt, wenn keines vorhanden ist.

Jede DB-Sicherung wird in ein einzelnes Verzeichnis geschrieben, sodass Sie einzelne DBs aus dem globalen Speicherauszug wiederherstellen können.

Zunächst von Start the Mongo DB - gehen Sie dazu zum Pfad als ->

C: \ Programme \ MongoDB \ Server \ 3.2 \ bin und klicken Sie auf die Datei mongod.exe , um den MongoDB-Server zu starten.

Befehl zum Exportieren in Windows

• Befehl zum Exportieren der MongoDB-Datenbank in Windows vom "Remote-Server" auf den lokalen Computer im Verzeichnis C: / Users / Desktop / temp-Ordner vom Remote-Server mit der internen IP-Adresse und dem internen Port.

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

Befehl zum Importieren in Windows

• Befehl zum Importieren der MongoDB-Datenbank in Windows auf den "Remote-Server" aus dem lokalen Computerverzeichnis C: / Users / Desktop / temp-folder / db-dir

C:> mongorestore --host = ip --port = 27017 -d C: / Benutzer / Desktop / temporärer Ordner / Datenbankverzeichnis

#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. Öffnen Sie die Verbindung
2. Starten Sie den Server
3. Öffnen Sie die neue Eingabeaufforderung

Export:

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

Importieren:

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

Wo

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

Je nachdem, was Sie tun möchten, gibt es mehrere Optionen

1) Wenn Sie Ihre Datenbank in eine andere Mongo-Datenbank exportieren möchten, sollten Sie verwenden mongodump. Dadurch wird ein Ordner mit BSON-Dateien erstellt, die Metadaten enthalten, über die JSON nicht verfügen würde.

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

2) Wenn Sie Ihre Datenbank in JSON exportieren möchten, können Sie sie verwenden, es sei mongoexportdenn, Sie müssen jeweils eine Sammlung erstellen (dies ist beabsichtigt). Ich denke jedoch, dass es am einfachsten ist, die gesamte Datenbank mit zu exportieren mongodumpund dann in JSON zu konvertieren.

# -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

Für den Speicherauszug hat Ihre Datenbank die folgende CMD

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

Führen Sie zum Exportieren im JSON-Format die folgenden Befehle aus.

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