Como exportar todas as coleções no MongoDB?

Desejo exportar todas as coleções no MongoDB pelo comando:

mongoexport -d dbname -o Mongo.json

O resultado é:
Nenhuma coleção especificada!

O manual diz que, se você não especificar uma coleção, todas as coleções serão exportadas.
No entanto, por que isso não funciona?

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

Minha versão do MongoDB é 2.0.6.

Para pessoas preguiçosas, use mongodump, é mais rápido:

mongodump -d <database_name> -o <directory_backup>

E para "restaurá-lo / importá-lo" (em directory_backup / dump /):

mongorestore -d <database_name> <directory_backup>

Dessa forma, você não precisa lidar com todas as coleções individualmente. Basta especificar o banco de dados.

Observe que eu recomendaria não usar mongodump/ mongorestorepara armazenamentos de big data . É muito lento e depois de passar 10 / 20GB de dados, pode demorar horas para restaurar.

Eu escrevi o script bash para isso. Basta executá-lo com 2 parâmetros (nome do banco de dados, dir para armazenar arquivos).

#!/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 as etapas abaixo para criar um mongodump a partir do servidor e importá-lo para outro servidor / máquina local que tenha um nome de usuário e uma senha

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

Exportando todas as coleções usando mongodump, use o seguinte 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

Informe-nos onde você instalou o seu Mongo DB? (no Ubuntu ou no Windows)

• Para Windows:

  1. Antes de exportar, você deve se conectar ao seu Mongo DB no prompt do cmd e verifique se é capaz de se conectar ao seu host local.
  2. Agora abra um novo prompt de cmd e execute o comando abaixo,

  mongodump - nome do banco de dados db - caminho a ser salvo,
  por exemplo: mongodump - db mydb -, saída c: \ TEMP \ op.json

  3. Visite https://www.youtube.com/watch?v=hOCp3Jv6yKo para obter mais detalhes.

• Para o Ubuntu:

  1. Entre no seu terminal onde o Mongo DB está instalado e verifique se você consegue se conectar ao Mongo DB.
  2. Agora abra um novo terminal e execute o comando abaixo,

  mongodump -d nome do banco de dados -o nome do arquivo a ser salvo,
  por exemplo: mongodump -d mydb -o output.json

  3. Visite https://www.youtube.com/watch?v=5Fwd2ZB86gg para obter mais detalhes.

As respostas anteriores explicaram bem, estou adicionando minha resposta para ajudar caso você esteja lidando com um banco de dados remoto protegido por senha

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

Caso deseje conectar um servidor mongoDB remoto como mongolab.com, você deve passar credenciais de conexão, por exemplo.

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

Se você estiver bem com o formato bson, poderá usar o utilitário mongodump com o mesmo sinalizador -d. Ele irá despejar todas as coleções no diretório de despejo (o padrão, pode ser alterado através da opção -o) no formato bson. Você pode importar esses arquivos usando o utilitário mongorestore.

Você pode usar mongo --eval 'printjson(db.getCollectionNames())'para obter a lista de coleções e, em seguida, fazer uma exportação mongo em todas elas. Aqui está um exemplo em 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

Eu precisava da versão de script em lote do Windows. Esse tópico foi útil, então pensei em contribuir com minha resposta também.

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

Eu tive alguns problemas usando set /p COLLECTIONS=<__collections.txt, daí o for /fmétodo complicado .

Depois de tentar muitos exemplos complicados, descobri que uma abordagem muito simples funcionou para mim.

Eu só queria pegar um db de um db do local e importá-lo em uma instância remota:

na máquina local:

mongodump -d databasename

então scp'd meu despejo na minha máquina servidor:

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

então, a partir do diretório pai do despejo, simplesmente:

mongorestore 

e que importou o banco de dados.

assumindo que o serviço mongodb esteja sendo executado, é claro.

Se desejar, você pode exportar todas as coleções para csv sem especificar --fields(exportará todos os campos).

Em http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/, execute 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;

Você pode fazer isso usando o comando mongodump

Etapa 1: abrir o prompt de comando

Etapa 2: vá para a pasta bin da sua instalação do mongoDB (C: \ Arquivos de Programas \ MongoDB \ Server \ 4.0 \ bin)

Etapa 3: em seguida, execute o seguinte comando

mongodump -d your_db_name -o destination_path

your_db_name = test

destination_path = C: \ Usuários \ HP \ Desktop

Os arquivos exportados serão criados na pasta destination_path \ your_db_name (neste exemplo, C: \ Users \ HP \ Desktop \ test)

Referências: o7planning

Se você deseja despejar todas as coleções em todos os bancos de dados (que é uma interpretação abrangente da intenção do questionador original), use

mongodump

Todos os bancos de dados e coleções serão criados em um diretório chamado 'dump' no local 'atual'

Sei que essa é uma pergunta bastante antiga e que o mongodump / mongorestore é claramente o caminho certo se você deseja um resultado 100% fiel, incluindo índices.

No entanto, eu precisava de uma solução rápida e suja que provavelmente seria compatível com versões anteriores e anteriores entre as versões antiga e nova do MongoDB, desde que não haja nada de especialmente estranho. E por isso eu queria a resposta para a pergunta original.

Existem outras soluções aceitáveis ​​acima, mas esse pipeline Unix é relativamente curto e agradável:

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

Isso produz um .jsonarquivo com nome apropriado para cada coleção.

Observe que o nome do banco de dados ("mydatabase") aparece duas vezes. Estou assumindo que o banco de dados é local e você não precisa passar credenciais, mas é fácil fazer isso com ambos mongoe mongoexport.

Observe que estou usando o grep -vdescarte system.indexes, porque não quero que uma versão mais antiga do MongoDB tente interpretar uma coleção de sistemas de uma mais nova. Em vez disso, estou permitindo que meu aplicativo faça suas ensureIndexchamadas habituais para recriar os índices.

você pode criar um arquivo zip usando o seguinte comando. Ele criará um arquivo zip do banco de dados {dbname} fornecido. Você pode importar posteriormente o seguinte arquivo zip no seu mongo DB.

Window filepath=C:\Users\Username\mongo 

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

Aqui está o que funcionou para mim ao restaurar um banco de dados exportado:

mongorestore -d 0 ./0 --drop

onde ./ continha os arquivos bson exportados. Observe que --dropele substituirá os dados existentes.

se você deseja usar mongoexport e mongoimport para exportar / importar cada coleção do banco de dados, acho que esse utilitário pode ser útil para você. Eu usei utilidades semelhantes algumas vezes;

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

Se você deseja fazer backup de todos os dbs no servidor, sem ter a preocupação de que os dbs sejam chamados, use o seguinte 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

Isso usa o utilitário mongodump, que fará backup de todos os bancos de dados se nenhum for especificado.

Você pode colocar isso no seu cronjob, e ele será executado apenas se o processo mongod estiver em execução. Ele também criará o diretório de backup, se não houver nenhum.

Cada backup do banco de dados é gravado em um diretório individual, para que você possa restaurar bancos de dados individuais do dump global.

Primeiro, inicie o Mongo DB - para isso, vá para o caminho como ->

C: \ Arquivos de programas \ MongoDB \ Server \ 3.2 \ bin e clique no arquivo mongod.exe para iniciar o servidor MongoDB.

Comando no Windows para Exportar

• Comando para exportar o banco de dados MongoDB no Windows do "servidor remoto" para a máquina local no diretório C: / Users / Desktop / temp-folder do servidor remoto com o endereço IP e a porta internos.

C:> mongodump --host remote_ip_address: 27017 --db -o C: / Usuários / Desktop / pasta-temp

Comando no Windows para Importar

• Comando para importar o banco de dados MongoDB no Windows para "servidor remoto" do diretório C da máquina local: / Users / Desktop / temp-folder / db-dir

C:> mongorestore --host = ip --port = 27017 -d C: / Usuários / Desktop / pasta temporária / 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. Abra a conexão
2. Iniciar o servidor
3. abrir novo prompt de comando

Exportar:

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

Importar:

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

Onde

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

Existem várias opções, dependendo do que você deseja fazer

1) Se você deseja exportar seu banco de dados para outro banco de dados mongo, use mongodump. Isso cria uma pasta de arquivos BSON que possuem metadados que o JSON não teria.

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

2) Se você deseja exportar seu banco de dados para JSON, pode usar, mongoexportexceto que você deve fazer uma coleção por vez (isso é por design). No entanto, acho mais fácil exportar todo o banco de dados mongodumpe depois converter para 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 despejo, seu DB coloca o CMD abaixo

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

Para exportar no formato JSON, faça isso seguindo os comandos que você pode ver.

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