Comment exporter toute la collection dans MongoDB?
Je veux exporter toute la collection dans MongoDB avec la commande:
mongoexport -d dbname -o Mongo.json
Le résultat est:
Aucune collection spécifiée!
Le manuel dit, si vous ne spécifiez pas de collection, toutes les collections seront exportées.
Cependant, pourquoi ça ne marche pas?
http://docs.mongodb.org/manual/reference/mongoexport/#cmdoption-mongoexport--collection
Ma version de MongoDB est 2.0.6
Pour les paresseux comme moi, j'utilise mongodump c'est plus rapide:
mongodump -d <database_name> -o <directory_backup>
Et pour "restaurer/importer" cela, j’ai utilisé (à partir de directory_backup/dump /):
mongorestore -d <database_name> <directory_backup>
Avec cette solution, vous n'avez pas besoin de faire toutes les collections et d'exporter une à une. Spécifiez simplement la base de données. Je recommande de ne pas utiliser mongodump/mongorestore pour les grands stockages de données . 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 le script bash pour ça. Il suffit de l’exécuter avec 2 paramètres (nom de la base de données, répertoire 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 doté d'un nom d'utilisateur et d'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
S'il vous plaît laissez-nous savoir où vous avez installé votre Mongo DB? (soit dans Ubuntu ou dans Windows)
Pour les fenêtres:
- Avant d'exporter, vous devez vous connecter à l'invite cmd à votre base de données Mongo et vous assurer que vous êtes en mesure de vous connecter à votre hôte local.
- Maintenant, ouvrez une nouvelle invite cmd et exécutez la commande ci-dessous,
mongodump --db nom de la base de données --out chemin à enregistrer
Exemple: mongodump --db mydb --out c:\TEMP\op.json- Visitez https://www.youtube.com/watch?v=hOCp3Jv6yKo pour plus de détails.
Pour Ubuntu:
- Connectez-vous à votre terminal sur lequel Mongo DB est installé et assurez-vous de pouvoir vous connecter à votre Mongo DB.
- 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 à sauvegarder
Exemple: mongodump -d mydb -o output.json- Visitez https://www.youtube.com/watch?v=5Fwd2ZB86gg pour plus de détails.
Exporter toutes les collections en utilisant 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
Si vous êtes d'accord avec le format bson, vous pouvez utiliser l'utilitaire mongodump avec le même indicateur -d. Toutes les collections seront sauvegardées dans le répertoire de vidage (la valeur par défaut peut être modifiée 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 effectuer un mongoexport sur chacune d’elles. Voici un exemple en 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
J'avais besoin de la version de script batch Windows. Ce fil était utile, alors j'ai pensé y apporter ma réponse également.
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 en utilisant set /p COLLECTIONS=<__collections.txt, d'où la méthode compliquée for /f.
Si vous le souhaitez, vous pouvez exporter toutes les collections au format csv sans spécifier --fields (tous les champs seront exportés).
De http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ run this 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;
Si vous souhaitez vider toutes les collections de toutes les bases de données (ce qui est une interprétation expansive de l'intention de l'interrogateur initial), utilisez
mongodump
Toutes les bases de données et collections seront créées dans un répertoire appelé "dump" à l'emplacement "actuel"
Après avoir essayé de nombreux exemples compliqués, j’ai trouvé que cette approche très simple fonctionnait pour moi.
Je voulais juste prendre un dump d'une base de données locale et l'importer sur une instance distante:
sur la machine locale:
mongodump -d databasename
puis j'ai scp'd mon dump sur ma machine serveur:
scp -r dump [email protected]:~
puis à partir du répertoire parent du dump, simplement:
mongorestore
et qui a importé la base de données.
en supposant que le service mongodb fonctionne bien sûr.
vous pouvez créer un fichier Zip en utilisant la commande suivante. Il créera un fichier Zip de la base de données {nom_base} fourni. Vous pourrez ensuite importer le fichier Zip suivant dans votre base de données mongo.
Window filepath=C:\Users\Username\mongo
mongodump --archive={filepath}\+{filename}.gz --gzip --db {dbname}
Si vous souhaitez connecter un serveur mongoDB distant tel que mongolab.com, vous devez passer les informations de connexionEg.
mongoexport -h id.mongolab.com:60599 -u username -p password -d mydb -c mycollection -o mybackup.json
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
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ù ./contenu les fichiers bson exportés. Notez que le --drop écrasera les données existantes.
Je me rends compte que c’est une question assez ancienne et que mongodump/mongorestore est clairement la bonne manière si vous voulez un résultat 100% fidèle, index compris.
Cependant, j'avais besoin d'une solution rapide et délicate qui serait probablement compatible en amont et en aval entre les anciennes et les nouvelles versions de MongoDB, à condition que rien ne soit particulièrement loufoque. Et pour cela, je voulais la réponse à la question initiale.
Il existe d'autres solutions acceptables ci-dessus, mais ce pipeline Unix est relativement court et simple:
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 fichier .json nommé de manière appropriée pour chaque collection.
Notez que le nom de la base de données ("mydatabase") apparaît deux fois. Je suppose que la base de données est locale et que vous n'avez pas besoin de transmettre les informations d'identification, mais il est facile de le faire avec mongo et mongoexport.
Notez que j'utilise grep -v pour supprimer system.indexes, car je ne souhaite pas qu'une ancienne version de MongoDB tente d'interpréter une collection système à partir d'une nouvelle. J'autorise plutôt mon application à effectuer ses appels ensureIndex habituels pour recréer les index.
si vous voulez utiliser mongoexport et mongoimport pour exporter/importer chaque collection de la base de données, je pense que cet utilitaire peut vous être utile. 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
Déjà, vous pouvez faire ce genre d'opérations avec une interface graphique comme Robomongo ou Mongochef.
Si vous souhaitez sauvegarder toutes les bases de données sur le serveur, sans vous soucier de leur appel, 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
Ceci 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 travail cron, et il ne sera exécuté 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 étant écrite dans un répertoire individuel, vous pouvez restaurer des bases de données individuelles à partir du vidage global.
#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
Il y a plusieurs options en fonction de 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 au format JSON, vous can utilisez mongoexport, sauf que vous devez le faire une collection à la fois (ceci est voulu par la conception). Cependant, je pense qu'il est plus facile d'exporter la totalité de la base de données avec mongodump, puis de le 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
Tout d'abord, de Démarrer la base de données Mongo - pour cela, allez dans 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 sous Windows à exporter
- Commande pour exporter la base de données MongoDB sous Windows de "serveur distant" vers la machine locale dans le répertoire C:/Utilisateurs/Bureau/dossier-temporaire 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 à importer dans Windows
- Commande pour importer la base de données MongoDB sous Windows sur "serveur distant" à partir du répertoire de l'ordinateur local C:/Utilisateurs/Bureau/dossier-temporaire/répertoire-répertoire
C:> mongorestore --Host = ip --port = 27017 -d C:/Utilisateurs/Bureau/dossier-temporaire/répertoire-bd
Pour le dump, votre base de données suit le CMD ci-dessous
mongodump -d <your d name> -o <dump path>
Ex:mongodump -d qualetics -o D:\dbpackup\qualetics
Vous pouvez le faire en utilisant la commande mongodump
Étape 1: Ouvrez 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_pathyour_db_name = test
destination_path = C:\Users\HP\Desktop
Les fichiers exportés seront créés dans le dossier destination_path\votre_nom_db (dans cet exemple, C:\Users\HP\Desktop\test).
Références: o7planning
- Ouvrez la connexion
- Démarrer le serveur
- ouvrir une nouvelle invite de commande
Exportation:
mongo/bin> mongoexport -d webmitta -c domain -o domain-k.json
Importation:
mongoimport -d dbname -c newCollecionname --file domain-k.json
Où
webmitta(db name)
domain(Collection Name)
domain-k.json(output file name)