¿Cómo exportar todas las colecciones en MongoDB?

Quiero exportar todas las colecciones en MongoDB con el comando:

mongoexport -d dbname -o Mongo.json

El resultado es: ¡
Ninguna colección especificada!

El manual dice que si no especifica una colección, todas las colecciones se exportarán.
Sin embargo, ¿por qué esto no funciona?

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

Mi versión de MongoDB es 2.0.6.

Para gente perezosa, use mongodump, es más rápido:

mongodump -d <database_name> -o <directory_backup>

Y para "restaurar / importar" (desde directorio_backup / dump /):

mongorestore -d <database_name> <directory_backup>

De esta manera, no necesita tratar con todas las colecciones individualmente. Solo especifique la base de datos.

Tenga en cuenta que recomendaría no usar mongodump/ mongorestorepara grandes almacenes de datos . Es muy lento y una vez que supera los 10 / 20GB de datos, puede tomar horas restaurarlos.

Escribí un script bash para eso. Simplemente ejecútelo con 2 parámetros (nombre de la base de datos, directorio para almacenar archivos).

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

Siga los pasos a continuación para crear un mongodump desde el servidor e importarlo en otro servidor / máquina local que tenga un nombre de usuario y una contraseña

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

Exportar todas las colecciones usando mongodump usa el siguiente comando

mongodump -d database_name -o directory_to_store_dumps

Para restaurar use este comando

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Por favor, háganos saber dónde ha instalado su Mongo DB? (ya sea en Ubuntu o en Windows)

• Para ventanas:

  1. Antes de exportar, debe conectarse a su Mongo DB en cmd prompt y asegurarse de que puede conectarse a su host local.
  2. Ahora abra un nuevo indicador de cmd y ejecute el siguiente comando,

  mongodump --db nombre de la base de datos --out ruta para guardar,
  por ejemplo: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Visita https://www.youtube.com/watch?v=hOCp3Jv6yKo para obtener más detalles.

• Para Ubuntu:

  1. Inicie sesión en su terminal donde está instalado Mongo DB y asegúrese de poder conectarse a su Mongo DB.
  2. Ahora abra una nueva terminal y ejecute el siguiente comando,

  mongodump -d nombre de la base de datos -o nombre de archivo para guardar,
  por ejemplo: mongodump -d mydb -o output.json

  3. Visita https://www.youtube.com/watch?v=5Fwd2ZB86gg para obtener más detalles.

Las respuestas anteriores lo explicaron bien, estoy agregando mi respuesta para ayudar en caso de que esté tratando con una base de datos remota protegida por contraseña

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

En caso de que desee conectar un servidor remoto de mongoDB como mongolab.com, debe pasar las credenciales de conexión, por ejemplo.

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

Si está de acuerdo con el formato bson, puede usar la utilidad mongodump con el mismo indicador -d. Volcará todas las colecciones al directorio de volcado (el valor predeterminado, se puede cambiar a través de la opción -o) en el formato bson. Luego puede importar estos archivos utilizando la utilidad mongorestore.

Puede usar mongo --eval 'printjson(db.getCollectionNames())'para obtener la lista de colecciones y luego hacer una exportación de mongo en todas ellas. Aquí hay un ejemplo en rubí

  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

Necesitaba la versión del script por lotes de Windows. Este hilo fue útil, así que pensé que también contribuiría con mi respuesta.

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

Tuve algunos problemas con el uso set /p COLLECTIONS=<__collections.txt, de ahí el for /fmétodo complicado .

Después de probar muchos ejemplos complicados, descubrí que un enfoque muy simple funcionó para mí.

Solo quería tomar un volcado de una base de datos local e importarlo en una instancia remota:

en la máquina local:

mongodump -d databasename

luego scp'd mi volcado a mi máquina servidor:

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

luego desde el directorio padre del basurero simplemente:

mongorestore 

y eso importó la base de datos.

suponiendo que el servicio mongodb se esté ejecutando, por supuesto.

Si lo desea, puede exportar todas las colecciones a csv sin especificar --fields(exportará todos los campos).

Desde http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ ejecute este 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;

Puedes hacerlo usando el comando mongodump

Paso 1: abrir el símbolo del sistema

Paso 2: vaya a la carpeta bin de su instalación de mongoDB (C: \ Archivos de programa \ MongoDB \ Server \ 4.0 \ bin)

Paso 3: luego ejecuta el siguiente comando

mongodump -d your_db_name -o destination_path

your_db_name = prueba

destination_path = C: \ Users \ HP \ Desktop

Los archivos exportados se crearán en la carpeta destination_path \ your_db_name (en este ejemplo C: \ Users \ HP \ Desktop \ test)

Referencias: o7planning

Si desea volcar todas las colecciones en todas las bases de datos (que es una interpretación expansiva de la intención del interrogador original), use

mongodump

Todas las bases de datos y colecciones se crearán en un directorio llamado 'volcado' en la ubicación 'actual'

Me doy cuenta de que esta es una pregunta bastante antigua y que mongodump / mongorestore es claramente la forma correcta si desea un resultado 100% fiel, incluidos los índices.

Sin embargo, necesitaba una solución rápida y sucia que probablemente fuera compatible con versiones anteriores y nuevas de MongoDB, siempre que no haya nada especialmente extraño. Y para eso quería la respuesta a la pregunta original.

Hay otras soluciones aceptables arriba, pero esta tubería de Unix es relativamente corta y dulce:

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

Esto produce un .jsonarchivo con el nombre apropiado para cada colección.

Tenga en cuenta que el nombre de la base de datos ("mydatabase") aparece dos veces. Supongo que la base de datos es local y no necesita pasar credenciales, pero es fácil hacerlo con ambos mongoy mongoexport.

Tenga en cuenta que estoy usando grep -vpara descartar system.indexes, porque no quiero que una versión anterior de MongoDB intente interpretar una colección del sistema de una nueva. En cambio, estoy permitiendo que mi aplicación realice sus ensureIndexllamadas habituales para recrear los índices.

puede crear un archivo zip utilizando el siguiente comando. Se creará un archivo zip de la base de datos {dbname} proporcionada. Posteriormente, puede importar el siguiente archivo zip en su base de datos mongo.

Window filepath=C:\Users\Username\mongo 

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

Esto es lo que funcionó para mí al restaurar una base de datos exportada:

mongorestore -d 0 ./0 --drop

donde ./contenía los archivos bson exportados. Tenga en cuenta que --dropsobrescribirá los datos existentes.

Si desea utilizar mongoexport y mongoimport para exportar / importar cada colección de la base de datos, creo que esta utilidad puede serle útil. He usado utilidades similares un par de veces;

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 desea hacer una copia de seguridad de todos los dbs en el servidor, sin preocuparse de que se llamen los dbs, use el siguiente script de 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

Esto utiliza la utilidad mongodump, que respaldará todas las bases de datos si no se especifica ninguna.

Puede poner esto en su cronjob, y solo se ejecutará si se está ejecutando el proceso mongod. También creará el directorio de respaldo si no existe ninguno.

Cada copia de seguridad de la base de datos se escribe en un directorio individual, por lo que puede restaurar las bases de datos individuales del volcado global.

Primero, de Iniciar el Mongo DB - para eso ve a la ruta como ->

C: \ Archivos de programa \ MongoDB \ Server \ 3.2 \ bin y haga clic en el archivo mongod.exe para iniciar el servidor MongoDB.

Comando en Windows para exportar

• Comando para exportar la base de datos MongoDB en Windows desde el "servidor remoto" a la máquina local en el directorio C: / Users / Desktop / temp-folder desde el servidor remoto con la dirección IP interna y el puerto.

C:> mongodump --host dirección_ip_remoto: 27017 --db -o C: / Users / Desktop / temp-folder

Comando en Windows para importar

• Comando para importar la base de datos MongoDB en Windows al "servidor remoto" desde el directorio local de la máquina 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. Abrir la conexión
2. Iniciar el servidor
3. abrir nuevo símbolo del sistema

Exportar:

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

Importar:

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

Dónde

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

Hay múltiples opciones dependiendo de lo que quieras hacer

1) Si desea exportar su base de datos a otra base de datos mongo, debe usarla mongodump. Esto crea una carpeta de archivos BSON que tienen metadatos que JSON no tendría.

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

2) Si desea exportar su base de datos a JSON, puede usarla, mongoexportexcepto que tiene que hacerlo una colección a la vez (esto es por diseño). Sin embargo, creo que es más fácil exportar toda la base de datos mongodumpy luego convertirla a 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

Para el volcado, su base de datos sigue el CMD a continuación

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

Para exportar en formato JSON, haga esto siguiendo los comandos que puede ver.

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