Jak wyeksportować wszystkie kolekcje w MongoDB?

Chcę wyeksportować wszystkie kolekcje w MongoDB za pomocą polecenia:

mongoexport -d dbname -o Mongo.json

Wynik jest następujący:
Nie określono kolekcji!

Instrukcja mówi, że jeśli nie określisz kolekcji, wszystkie kolekcje zostaną wyeksportowane.
Dlaczego jednak to nie działa?

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

Moja wersja MongoDB to 2.0.6.

Dla leniwych używaj mongodump, jest szybszy:

mongodump -d <database_name> -o <directory_backup>

Aby go „przywrócić / zaimportować” (z katalog_kopii_zapasowej / zrzutu /):

mongorestore -d <database_name> <directory_backup>

W ten sposób nie musisz zajmować się wszystkimi kolekcjami indywidualnie. Po prostu określ bazę danych.

Pamiętaj, że odradzam używanie mongodump/ mongorestoredo przechowywania dużych zbiorów danych . Jest bardzo powolny, a po przekroczeniu 10/20 GB danych przywracanie danych może potrwać kilka godzin.

Napisałem do tego skrypt bash. Wystarczy uruchomić go z 2 parametrami (nazwa bazy danych, katalog do przechowywania plików).

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

Wykonaj poniższe kroki, aby utworzyć mongodump z serwera i zaimportować go z innego serwera / komputera lokalnego, który ma nazwę użytkownika i hasło

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

Eksportując wszystkie kolekcje za pomocą mongodump, użyj następującego polecenia

mongodump -d database_name -o directory_to_store_dumps

Aby przywrócić, użyj tego polecenia

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Daj nam znać, gdzie zainstalowałeś swoją bazę danych Mongo? (w systemie Ubuntu lub w systemie Windows)

• Dla Windowsa:

  1. Przed eksportowaniem musisz połączyć się z bazą danych Mongo w wierszu polecenia cmd i upewnić się, że możesz połączyć się z hostem lokalnym.
  2. Teraz otwórz nowy monit cmd i wykonaj poniższe polecenie,

  mongodump --db nazwa bazy danych --out ścieżka do zapisania
  np .: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Odwiedź https://www.youtube.com/watch?v=hOCp3Jv6yKo, aby uzyskać więcej informacji.

• W przypadku Ubuntu:

  1. Zaloguj się do terminala, na którym zainstalowano DB Mongo i upewnij się, że możesz połączyć się z DB Mongo.
  2. Teraz otwórz nowy terminal i wykonaj poniższe polecenie,

  mongodump -d nazwa bazy danych -o nazwa pliku, aby zapisać
  np .: mongodump -d mydb -o output.json

  3. Odwiedź https://www.youtube.com/watch?v=5Fwd2ZB86gg, aby uzyskać więcej informacji.

Poprzednie odpowiedzi dobrze to wyjaśniały, dodaję swoją odpowiedź, aby pomóc w przypadku zdalnej bazy danych chronionej hasłem

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

Jeśli chcesz podłączyć zdalny serwer mongoDB, taki jak mongolab.com, powinieneś podać poświadczenia połączenia, np.

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

Jeśli nie masz nic przeciwko formatowi bson, możesz użyć narzędzia mongodump z tą samą flagą -d. Zrzuci wszystkie kolekcje do katalogu zrzutu (domyślnie, można to zmienić za pomocą opcji -o) w formacie bson. Następnie możesz zaimportować te pliki za pomocą narzędzia mongorestore.

Możesz użyć, mongo --eval 'printjson(db.getCollectionNames())'aby uzyskać listę kolekcji, a następnie wykonać mongoeksport na wszystkich z nich. Oto przykład w rubinie

  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

Potrzebowałem wersji wsadowej skryptu Windows. Ten wątek był przydatny, więc pomyślałem, że ja też wrócę do niego.

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

Miałem pewne problemy z używaniem set /p COLLECTIONS=<__collections.txt, stąd zwinięta for /fmetoda.

Po wypróbowaniu wielu zawiłych przykładów odkryłem, że bardzo proste podejście działa na mnie.

Chciałem tylko zrobić zrzut bazy danych z lokalnego i zaimportować do zdalnej instancji:

na komputerze lokalnym:

mongodump -d databasename

następnie scpdowałem mój zrzut do mojego serwera:

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

następnie z katalogu macierzystego zrzutu po prostu:

mongorestore 

i to zaimportowało bazę danych.

zakładając, że usługa mongodb działa oczywiście.

Jeśli chcesz, możesz wyeksportować wszystkie kolekcje do csv bez określania --fields(wyeksportuje wszystkie pola).

Z http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ uruchom ten skrypt 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;

Jeśli chcesz zrzucić wszystkie kolekcje we wszystkich bazach danych (co jest ekspansywną interpretacją intencji pierwotnego pytającego), użyj

mongodump

Wszystkie bazy danych i kolekcje zostaną utworzone w katalogu o nazwie „zrzut” w „bieżącej” lokalizacji

Możesz to zrobić za pomocą polecenia mongodump

Krok 1: Otwórz wiersz polecenia

Krok 2: Przejdź do folderu bin instalacji mongoDB (C: \ Program Files \ MongoDB \ Server \ 4.0 \ bin)

Krok 3: następnie wykonaj następujące polecenie

mongodump -d your_db_name -o destination_path

twoja_nazwa_db = test

destination_path = C: \ Users \ HP \ Desktop

Wyeksportowane pliki zostaną utworzone w folderze ścieżka_docelowa \ twoja_nazwa_db (w tym przykładzie C: \ Users \ HP \ Desktop \ test)

Referencje: o7planning

Zdaję sobie sprawę, że jest to dość stare pytanie i że mongodump / mongorestore jest wyraźnie właściwą drogą, jeśli chcesz uzyskać 100% wierny wynik, w tym indeksy.

Potrzebowałem jednak szybkiego i brudnego rozwiązania, które prawdopodobnie byłoby zgodne z poprzednimi i nowymi wersjami MongoDB, pod warunkiem, że nie dzieje się nic dziwnego. I za to chciałem uzyskać odpowiedź na pierwotne pytanie.

Istnieją inne akceptowalne rozwiązania powyżej, ale ten potok uniksowy jest stosunkowo krótki i słodki:

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

To tworzy odpowiednio nazwany .jsonplik dla każdej kolekcji.

Pamiętaj, że nazwa bazy danych („moja baza danych”) pojawia się dwukrotnie. Zakładam, że baza danych jest lokalna i nie musisz przekazywać poświadczeń, ale łatwo to zrobić zarówno z, jak mongoi z mongoexport.

Zauważ, że używam grep -vdo odrzucania system.indexes, ponieważ nie chcę, aby starsza wersja MongoDB próbowała interpretować kolekcję systemową z nowszej. Zamiast tego zezwalam mojej aplikacji na wykonywanie zwykłych ensureIndexwywołań w celu odtworzenia indeksów.

możesz utworzyć plik zip za pomocą następującego polecenia. Stworzy podany plik zip z bazą danych {nazwa_bazy}. Możesz później zaimportować następujący plik zip do bazy danych Mongo DB.

Window filepath=C:\Users\Username\mongo 

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

Oto, co działało dla mnie podczas przywracania wyeksportowanej bazy danych:

mongorestore -d 0 ./0 --drop

gdzie ./ zawierał wyeksportowane pliki bson. Pamiętaj, że --dropzastąpią istniejące dane.

jeśli chcesz używać mongoexport i mongoimport do eksportowania / importowania każdej kolekcji z bazy danych, myślę, że to narzędzie może być dla Ciebie pomocne. Kilka razy korzystałem z podobnego narzędzia;

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

Jeśli chcesz wykonać kopię zapasową wszystkich dbs na serwerze, nie martwiąc się, że zostaną one wywołane, użyj następującego skryptu powłoki:

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

Używa to narzędzia mongodump, które utworzy kopię zapasową wszystkich baz danych, jeśli nie zostanie określony.

Możesz umieścić to w swoim kronice, a będzie ono działać tylko wtedy, gdy uruchomiony zostanie proces mongod. Stworzy również katalog kopii zapasowej, jeśli nie istnieje.

Każda kopia zapasowa bazy danych jest zapisywana w osobnym katalogu, dzięki czemu można przywracać poszczególne bazy danych z globalnego zrzutu.

Najpierw uruchom DB bazy danych Mongo - w tym celu przejdź do ścieżki jako ->

C: \ Program Files \ MongoDB \ Server \ 3.2 \ bin i kliknij plik mongod.exe , aby uruchomić serwer MongoDB.

Polecenie w systemie Windows, aby wyeksportować

• Polecenie wyeksportowania bazy danych MongoDB w systemie Windows z „serwera zdalnego” na komputer lokalny w katalogu C: / Users / Desktop / temp-folder ze zdalnego serwera z wewnętrznym adresem IP i portem.

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

Polecenie w systemie Windows, aby zaimportować

• Polecenie importowania bazy danych MongoDB w systemie Windows do „zdalnego serwera” z lokalnego katalogu komputera 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. Otwórz połączenie
2. Uruchom serwer
3. otwórz nowy wiersz polecenia

Eksport:

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

Import:

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

Gdzie

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

Istnieje wiele opcji w zależności od tego, co chcesz zrobić

1) Jeśli chcesz wyeksportować bazę danych do innej bazy danych Mongo, powinieneś użyć mongodump. Spowoduje to utworzenie folderu plików BSON, które mają metadane, których JSON nie miałby.

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

2) Jeśli chcesz wyeksportować swoją bazę danych do JSON, możesz jej użyć, mongoexportz wyjątkiem tego, że musisz to zrobić po jednej kolekcji na raz (jest to zgodne z projektem). Myślę jednak, że najłatwiej jest wyeksportować całą bazę danych, mongodumpa następnie przekonwertować na 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

Dla zrzutu, twoja DB odłóż poniżej CMD

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

Aby wyeksportować w formacie JSON, wykonaj następujące czynności, które możesz zobaczyć.

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