Comment exporter toutes les collections dans MongoDB?

Je souhaite exporter toutes les collections dans MongoDB par la commande:

mongoexport -d dbname -o Mongo.json

Le résultat est:
Aucune collection spécifiée!

Le manuel indique que si vous ne spécifiez pas de collection, toutes les collections seront exportées.
Cependant, pourquoi cela ne fonctionne-t-il pas?

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

Ma version MongoDB est 2.0.6.

Pour les paresseux, utilisez mongodump, c'est plus rapide:

mongodump -d <database_name> -o <directory_backup>

Et pour le "restaurer / importer" (à partir de directory_backup / dump /):

mongorestore -d <database_name> <directory_backup>

De cette façon, vous n'avez pas besoin de traiter toutes les collections individuellement. Spécifiez simplement la base de données.

Notez que je déconseille d'utiliser mongodump/ mongorestorepour les stockages de Big Data . Il est très lent et une fois que vous avez dépassé 10/20 Go de données, la restauration peut prendre des heures.

J'ai écrit un script bash pour ça. Il suffit de l'exécuter avec 2 paramètres (nom de la base de données, dir pour stocker les fichiers).

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

Suivez les étapes ci-dessous pour créer un mongodump à partir du serveur et l'importer sur un autre serveur / machine locale qui a un nom d'utilisateur et un mot de passe

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

Pour exporter toutes les collections à l'aide de mongodump, utilisez la commande suivante

mongodump -d database_name -o directory_to_store_dumps

Pour restaurer, utilisez cette commande

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Veuillez nous indiquer où vous avez installé votre Mongo DB? (soit sous Ubuntu soit sous Windows)

• Pour les fenêtres:

  1. Avant d'exporter, vous devez vous connecter à votre base de données Mongo dans l'invite cmd et vous assurer que vous pouvez vous connecter à votre hôte local.
  2. Ouvrez maintenant une nouvelle invite cmd et exécutez la commande ci-dessous,

  mongodump --db nom de la base de données --out chemin à enregistrer
  par exemple: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Visitez https://www.youtube.com/watch?v=hOCp3Jv6yKo pour plus de détails.

• Pour Ubuntu:

  1. Connectez-vous à votre terminal sur lequel Mongo DB est installé et assurez-vous que vous pouvez vous connecter à votre Mongo DB.
  2. Ouvrez maintenant un nouveau terminal et exécutez la commande ci-dessous,

  mongodump -d nom de la base de données -o nom du fichier à enregistrer,
  par exemple: mongodump -d mydb -o output.json

  3. Visitez https://www.youtube.com/watch?v=5Fwd2ZB86gg pour plus de détails.

Les réponses précédentes l'ont bien expliqué, j'ajoute ma réponse pour vous aider au cas où vous auriez affaire à une base de données distante protégée par mot de passe

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

Dans le cas où vous souhaitez connecter un serveur mongoDB distant comme mongolab.com, vous devez transmettre les informations de connexion, par exemple.

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

Si vous êtes d'accord avec le format bson, vous pouvez utiliser l'utilitaire mongodump avec le même indicateur -d. Il videra toutes les collections dans le répertoire de vidage (par défaut, peut être modifié via l'option -o) au format bson. Vous pouvez ensuite importer ces fichiers à l'aide de l'utilitaire mongorestore.

Vous pouvez utiliser mongo --eval 'printjson(db.getCollectionNames())'pour obtenir la liste des collections, puis faire un mongoexport sur chacune d'entre elles. Voici un exemple en rubis

  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

J'avais besoin de la version du script batch Windows. Ce fil était utile, alors j'ai pensé que j'y contribuerais aussi.

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

J'ai eu quelques problèmes à utiliser set /p COLLECTIONS=<__collections.txt, d'où la for /fméthode alambiquée .

J'ai trouvé après avoir essayé de nombreux exemples compliqués que l'approche très simple a fonctionné pour moi.

Je voulais juste prendre un vidage d'une base de données du local et l'importer sur une instance distante:

sur la machine locale:

mongodump -d databasename

puis je scp'd mon vidage sur ma machine serveur:

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

puis à partir du répertoire parent du vidage simplement:

mongorestore 

et qui a importé la base de données.

en supposant que le service mongodb fonctionne bien sûr.

Si vous le souhaitez, vous pouvez exporter toutes les collections vers csv sans spécifier --fields(exportera tous les champs).

Depuis http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ exécutez ce 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;

Vous pouvez le faire en utilisant la commande mongodump

Étape 1: ouvrir l'invite de commande

Étape 2: accédez au dossier bin de votre installation mongoDB (C: \ Program Files \ MongoDB \ Server \ 4.0 \ bin)

Étape 3: puis exécutez la commande suivante

mongodump -d your_db_name -o destination_path

your_db_name = test

destination_path = C: \ Users \ HP \ Desktop

Les fichiers exportés seront créés dans le dossier destination_path \ your_db_name (dans cet exemple C: \ Users \ HP \ Desktop \ test)

Références: o7planning

Si vous souhaitez vider toutes les collections dans toutes les bases de données (ce qui est une interprétation extensive de l'intention du questionneur d'origine), utilisez

mongodump

Toutes les bases de données et collections seront créées dans un répertoire appelé «dump» à l'emplacement «actuel»

Je me rends compte que c'est une question assez ancienne et que mongodump / mongorestore est clairement la bonne façon si vous voulez un résultat 100% fidèle, y compris les index.

Cependant, j'avais besoin d'une solution rapide et sale qui serait probablement compatible en amont et en aval entre les anciennes et les nouvelles versions de MongoDB, à condition qu'il n'y ait rien de particulièrement loufoque. Et pour cela, je voulais la réponse à la question d'origine.

Il existe d'autres solutions acceptables ci-dessus, mais ce pipeline Unix est relativement court et doux:

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

Cela produit un nom approprié .json fichier pour chaque collection.

Notez que le nom de la base de données ("ma base de données") apparaît deux fois. Je suppose que la base de données est locale et que vous n'avez pas besoin de transmettre vos informations d'identification, mais il est facile de le faire à la fois avec mongoetmongoexport .

Notez que j'utilise grep -vpour supprimer system.indexes, car je ne veux pas qu'une ancienne version de MongoDB essaie d'interpréter une collection système à partir d'une plus récente. Au lieu de cela, j'autorise mon application à effectuer ses ensureIndexappels habituels pour recréer les index.

vous pouvez créer un fichier zip en utilisant la commande suivante. Il créera le fichier zip de la base de données {dbname} fourni. Vous pourrez ultérieurement importer le fichier zip suivant dans votre mongo DB.

Window filepath=C:\Users\Username\mongo 

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

Voici ce qui a fonctionné pour moi lors de la restauration d'une base de données exportée:

mongorestore -d 0 ./0 --drop

où ./ contient les fichiers bson exportés. Notez que le --dropremplacera les données existantes.

si vous souhaitez utiliser mongoexport et mongoimport pour exporter / importer chaque collection de la base de données, je pense que cet utilitaire peut vous être utile. J'ai utilisé des utilitaires similaires plusieurs fois;

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

Si vous souhaitez sauvegarder tous les dbs sur le serveur, sans vous soucier de l'appel des dbs, utilisez le script shell suivant:

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

Cela utilise l'utilitaire mongodump, qui sauvegarde toutes les bases de données si aucune n'est spécifiée.

Vous pouvez mettre cela dans votre cronjob, et cela ne fonctionnera que si le processus mongod est en cours d'exécution. Il créera également le répertoire de sauvegarde s'il n'en existe pas.

Chaque sauvegarde de base de données est écrite dans un répertoire individuel, vous pouvez donc restaurer des bases de données individuelles à partir du vidage global.

Tout d'abord, de démarrer la base de données Mongo - pour cela, allez sur le chemin comme ->

C: \ Program Files \ MongoDB \ Server \ 3.2 \ bin et cliquez sur le fichier mongod.exe pour démarrer le serveur MongoDB.

Commande dans Windows pour exporter

• Commande pour exporter la base de données MongoDB sous Windows du "serveur distant" vers la machine locale dans le répertoire C: / Users / Desktop / temp-folder du serveur distant avec l'adresse IP interne et le port.

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

Commande dans Windows pour importer

• Commande pour importer la base de données MongoDB dans Windows vers "serveur distant" à partir du répertoire de l'ordinateur local 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. Ouvrez la connexion
2. Démarrez le serveur
3. ouvrir une nouvelle invite de commande

Exportation:

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

Importer:

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

Où

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

Il y a plusieurs options selon ce que vous voulez faire

1) Si vous souhaitez exporter votre base de données vers une autre base de données mongo, vous devez utiliser mongodump. Cela crée un dossier de fichiers BSON contenant des métadonnées que JSON n'aurait pas.

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

2) Si vous souhaitez exporter votre base de données dans JSON, vous pouvez utiliser, mongoexportsauf que vous devez le faire une collection à la fois (c'est par conception). Cependant, je pense qu'il est plus facile d'exporter la base de données entière avec mongodumppuis de convertir en 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

Pour le vidage, votre DB en jachère le CMD ci-dessous

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

Pour exporter au format JSON, procédez comme suit en suivant les commandes que vous pouvez voir.

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