Wie kann ich die gesamte Sammlung in MongoDB exportieren?

Für faule Leute wie mich benutze ich Mongodump, es ist schneller:

mongodump -d <database_name> -o <directory_backup>

Und zum "Wiederherstellen/Importieren" habe ich (von directory_backup/dump /) verwendet:

mongorestore -d <database_name> <directory_backup>

Bei dieser Lösung müssen Sie nicht alle Sammlungen einzeln sortieren und exportieren. Geben Sie einfach die Datenbank an. Ich würde die Verwendung von Mongodump/Mongorestore für Big Data Storage empfehlen. Es ist sehr langsam und wenn Sie erst einmal 10/20 GB an Daten erhalten 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 importieren Sie ihn auf einem anderen Server/lokalen Computer, der einen Benutzernamen und ein Kennwort enthält

1. mongodump -d dbname -o dumpname -u username -p password
2. scp -r [email protected]:~/location/of/dumpname ./
3. mongorestore -d dbname dumpname/dbname/ -u username -p password

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 cmd Prompt eine Verbindung zu Ihrer Mongo DB herstellen und sicherstellen, dass Sie eine Verbindung zu Ihrem lokalen Host herstellen können. 
  2. Öffnen Sie nun eine neue 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 , um weitere Informationen zu erhalten. 

• Für Ubuntu: 

  1. Melden Sie sich an 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 Dateiname zum Speichern
  zB: mongodump -d mydb -o output.json 

  3. Besuchen Sie https://www.youtube.com/watch?v=5Fwd2ZB86gg , um weitere Informationen zu erhalten.

Wenn Sie alle Sammlungen mit Mongodump exportieren, verwenden Sie den folgenden Befehl 

mongodump -d database_name -o directory_to_store_dumps

Zum Wiederherstellen verwenden Sie diesen Befehl

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Wenn Sie mit dem bson-Format zufrieden sind, können Sie das Dienstprogramm mongodump mit demselben Flag -d verwenden. Es werden alle Sammlungen in das Dump-Verzeichnis (der Standardwert kann mit der Option -o geändert werden) im bson-Format ausgegeben. Sie können diese Dateien dann mit dem Dienstprogramm mongorestore importieren.

Sie können mongo --eval 'printjson(db.getCollectionNames())' verwenden, um die Liste der Sammlungen abzurufen Anschließend können Sie einen Mongoexport für alle durchführen. Hier ist ein Beispiel in Ruby 

  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-Skript-Version. 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 Probleme mit set /p COLLECTIONS=<__collections.txt, daher die gewundene for /f-Methode.

Wenn Sie möchten, können Sie alle Sammlungen nach csv exportieren, ohne --fields anzugeben (alle Felder werden exportiert).

Von http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ führen Sie dieses Bash-Skript aus

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

Nachdem ich viele verschlungene Beispiele ausprobiert hatte, funktionierte dieser einfache Ansatz für mich.

Ich wollte nur einen Dump von einer lokalen Datenbank von lokal erstellen und auf eine Remote-Instanz importieren:

auf dem lokalen Rechner:

mongodump -d databasename

dann scp'd ich meinen Dump auf meinem Server-Rechner:

scp -r dump [email protected]:~

dann aus dem übergeordneten Verzeichnis des Dumps einfach:

mongorestore 

und das importierte die Datenbank.

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

sie können eine ZIP-Datei erstellen, indem Sie den folgenden Befehl verwenden. Es erstellt eine ZIP-Datei der Datenbank {Datenbankname}. 

Window filepath=C:\Users\Username\mongo 

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

Wenn Sie einen Remote-MongoDB-Server wie mongolab.com anschließen möchten, müssen Sie die Verbindungsberechtigungsnachweise.

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

Vorherige Antworten haben es gut erklärt. Ich füge meine Antwort hinzu, um 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

Folgendes hat für mich beim Wiederherstellen einer exportierten Datenbank funktioniert:

mongorestore -d 0 ./0 --drop

dabei enthält ./ die exportierten bson-Dateien. Beachten Sie, dass der --drop vorhandene Daten überschreibt.

Mir ist klar, dass dies eine ziemlich alte Frage ist und dass Mongodump/Mongorestore eindeutig der richtige Weg ist, wenn Sie ein 100% iges Ergebnis (einschließlich Indizes) wünschen.

Ich brauchte jedoch eine schnelle und schmutzige Lösung, die wahrscheinlich vor- und rückwärtskompatibel zwischen alten und neuen MongoDB-Versionen wäre, vorausgesetzt, es gibt nichts besonders Verrücktes. 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 für jede Sammlung eine entsprechend benannte .json-Datei erstellt. 

Beachten Sie, dass der Datenbankname ("meine Datenbank") zweimal angezeigt wird. Ich gehe davon aus, dass die Datenbank lokal ist und Sie keine Anmeldeinformationen übergeben müssen. Dies ist jedoch sowohl mit mongo als auch mit mongoexport einfach möglich.

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

wenn Sie mongoexport und mongoimport verwenden möchten, um jede Sammlung aus der Datenbank zu exportieren/importieren, denke ich dieses Dienstprogramm kann für Sie hilfreich sein .. _. Ich habe ein ähnliches Dienstprogramm verwendet mal;

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

Mit einer GUI wie Robomongo oder Mongochef können Sie solche Operationen bereits durchführen.

Wenn Sie alle dbs auf dem Server sichern möchten, ohne sich Sorgen zu machen, dass die dbs 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, das alle DBs sichert, wenn keine angegeben sind.

Sie können dies in Ihren Cronjob einfügen und es wird nur ausgeführt, wenn der Mongod-Prozess ausgeführt wird. Das Sicherungsverzeichnis wird auch 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.

#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

Es gibt mehrere Optionen, je nachdem, was Sie tun möchten

1) Wenn Sie Ihre Datenbank in eine andere Mongo-Datenbank exportieren möchten, sollten Sie mongodump verwenden. Dadurch wird ein Ordner mit BSON-Dateien erstellt, die Metadaten enthalten, die JSON nicht hätte.

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

2) Wenn Sie Ihre Datenbank in JSON exportieren möchten, können Sie can mongoexport verwenden, es sei denn, Sie müssen jeweils eine Auflistung durchführen (dies ist beabsichtigt). Ich denke jedoch, dass es am einfachsten ist, die gesamte Datenbank mit mongodump zu exportieren und dann nach 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

Zuerst von Start the Mongo DB - für den Pfad als -> gehen 

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

Befehl in Windows zum Exportieren

• 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:/Benutzer/Desktop/Temp-Ordner

Befehl in Windows zum Importieren

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

C:> mongorestore - Host = ip --port = 27017 -d C:/Benutzer/Desktop/Temp-Ordner/Datenbankverzeichnis

Befolgen Sie für die Sicherung Ihrer Datenbank die unten stehende CMD

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

Sie können dies mit dem Befehl mongodump tun

Schritt 1: Öffnen Sie die Eingabeaufforderung

Schritt 2: Wechseln Sie in den 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_DB-Name erstellt (in diesem Beispiel C:\Users\HP\Desktop\test).

Referenzen: o7planning

1. Öffnen Sie die Verbindung
2. Starten Sie den Server
3. neue Eingabeaufforderung öffnen

Export:

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

Einführen:

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

Woher 

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