registro - mongodb operaciones

¿Cómo exportar toda la colección en MongoDB?

Question

Quiero exportar toda la colección en MongoDB por el comando:

mongoexport -d dbname -o Mongo.json

El resultado es:
¡Ninguna colección especificada!

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

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

Mi versión de MongoDB es 2.0.6

Answer 1

1. Abre la conexion
2. Iniciar el servidor
3. abrir nueva línea de comandos

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)

Answer 2

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

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 [email protected]:~

luego desde el directorio padre del volcado simplemente:

mongorestore 

Y eso importó la base de datos.

asumiendo que el servicio mongodb está funcionando, por supuesto.

Answer 3

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

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

Answer 4

Escribí el guión de bash para eso. Simplemente ejecútelo con 2 parámetros (nombre de la base de datos, dir 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

Answer 5

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 el --drop sobrescribirá los datos existentes.

Answer 6

Exportando todas las colecciones usando mongodump usa el siguiente comando

mongodump -d database_name -o directory_to_store_dumps

Para restaurar usa este comando

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Answer 7

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

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

Answer 8

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 entre las versiones antiguas 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 más arriba, pero este oleoducto de Unix es relativamente corto 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 archivo .json 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 es necesario que pase las credenciales, pero es fácil hacerlo con mongo y mongoexport .

Tenga en cuenta que estoy usando grep -v para descartar system.indexes , porque no quiero que una versión anterior de MongoDB intente interpretar una colección de sistemas de una más nueva. En su lugar, estoy permitiendo que mi aplicación realice las llamadas usuales de ensureIndex para recrear los índices.

Answer 9

Necesitaba la versión de 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 al usar set /p COLLECTIONS=<__collections.txt , por lo tanto, el método for /f convoluted.

Answer 10

Para gente perezosa como yo, uso mongodump es más rápido:

mongodump -d <database_name> -o <directory_backup>

Y para "restaurar / importar" que utilicé (desde directory_backup / dump /):

mongorestore -d <database_name> <directory_backup>

Con esta solución, no es necesario que todas las colecciones y exportaciones se realicen una por una. Simplemente especifique la base de datos. No recomendaría el uso de mongodump / mongorestore para grandes almacenes de datos . Es muy lento y, una vez que supera los 10/20 GB de datos, puede tardar horas en restaurarse.

Answer 11

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

• Para ventanas:

  1. Antes de exportar, debe conectarse a su Mongo DB en el indicador de cmd 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 abre un nuevo terminal y ejecuta el siguiente comando,

  mongodump -d nombre de 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.

Answer 12

Puede usar mongo --eval ''printjson(db.getCollectionNames())'' para obtener la lista de colecciones y luego hacer una exportación mongo en todos ellos. 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

Answer 13

Si desea hacer una copia de seguridad de todos los dbs en el servidor, sin tener la preocupación de que se llame a 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 hará una copia de seguridad de todos los DB si no se especifica ninguno.

Puede poner esto en su trabajo cronológico, y solo se ejecutará si el proceso mongod se está ejecutando. También creará el directorio de copia de seguridad si no existe ninguno.

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

Answer 14

Si desea utilizar mongoexport y mongoimport para exportar / importar cada colección desde la base de datos, creo que esta utilidad puede ser útil para usted. He usado utilidad similar 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

Answer 15

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

mongodump

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

Answer 16

Si está de acuerdo con el formato bson, puede usar la utilidad mongodump con la misma marca -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. A continuación, puede importar estos archivos utilizando la utilidad mongorestore.

Answer 17

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 de 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;

Answer 18

Siga los pasos a continuación para crear un mongodump desde el servidor e importarlo a 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

Answer 19

Ya puedes hacer ese tipo de operaciones con una GUI como Robomongo o Mongochef.

Answer 20

puede crear un archivo zip usando el siguiente comando. Creará un archivo zip de la base de datos {dbname} provisto. Más tarde 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}

Answer 21

#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