/usr/bin/mongodump

Usage:
  mongodump <options> <connection-string>

Export the content of a running server into .bson files.

Specify a database with -d and a collection with -c to only dump that database or collection.

Connection strings must begin with mongodb:// or mongodb+srv://.

See http://docs.mongodb.com/database-tools/mongodump/ for more information.

general options:
      --help                                                print usage
      --version                                             print the tool
                                                            version and exit
      --config=                                             path to a
                                                            configuration file

verbosity options:
  -v, --verbose=<level>                                     more detailed log
                                                            output (include
                                                            multiple times for
                                                            more verbosity,
                                                            e.g. -vvvvv, or
                                                            specify a numeric
                                                            value, e.g.
                                                            --verbose=N)
      --quiet                                               hide all log output

connection options:
  -h, --host=<hostname>                                     mongodb host to
                                                            connect to
                                                            (setname/host1,host-

                                                            2 for replica sets)
      --port=<port>                                         server port (can
                                                            also use --host
                                                            hostname:port)

ssl options:
      --ssl                                                 connect to a mongod
                                                            or mongos that has
                                                            ssl enabled
      --sslCAFile=<filename>                                the .pem file
                                                            containing the root
                                                            certificate chain
                                                            from the
                                                            certificate
                                                            authority
      --sslPEMKeyFile=<filename>                            the .pem file
                                                            containing the
                                                            certificate and key
      --sslPEMKeyPassword=<password>                        the password to
                                                            decrypt the
                                                            sslPEMKeyFile, if
                                                            necessary
      --sslCRLFile=<filename>                               the .pem file
                                                            containing the
                                                            certificate
                                                            revocation list
      --sslFIPSMode                                         use FIPS mode of
                                                            the installed
                                                            openssl library
      --tlsInsecure                                         bypass the
                                                            validation for
                                                            server's
                                                            certificate chain
                                                            and host name

authentication options:
  -u, --username=<username>                                 username for
                                                            authentication
  -p, --password=<password>                                 password for
                                                            authentication
      --authenticationDatabase=<database-name>              database that holds
                                                            the user's
                                                            credentials
      --authenticationMechanism=<mechanism>                 authentication
                                                            mechanism to use
      --awsSessionToken=<aws-session-token>                 session token to
                                                            authenticate via
                                                            AWS IAM

kerberos options:
      --gssapiServiceName=<service-name>                    service name to use
                                                            when authenticating
                                                            using
                                                            GSSAPI/Kerberos
                                                            (default: mongodb)
      --gssapiHostName=<host-name>                          hostname to use
                                                            when authenticating
                                                            using
                                                            GSSAPI/Kerberos
                                                            (default: <remote
                                                            server's address>)

namespace options:
  -d, --db=<database-name>                                  database to use
  -c, --collection=<collection-name>                        collection to use

uri options:
      --uri=mongodb-uri                                     mongodb uri
                                                            connection string

query options:
  -q, --query=                                              query filter, as a
                                                            v2 Extended JSON
                                                            string, e.g.,
                                                            '{"x":{"$gt":1}}'
      --queryFile=                                          path to a file
                                                            containing a query
                                                            filter (v2 Extended
                                                            JSON)
      --readPreference=<string>|<json>                      specify either a
                                                            preference mode
                                                            (e.g. 'nearest') or
                                                            a preference json
                                                            object (e.g.
                                                            '{mode: "nearest",
                                                            tagSets: [{a:
                                                            "b"}],
                                                            maxStalenessSeconds-

                                                            : 123}')
      --forceTableScan                                      force a table scan
                                                            (do not use
                                                            $snapshot or hint
                                                            _id). Deprecated
                                                            since this is
                                                            default behavior on
                                                            WiredTiger

output options:
  -o, --out=<directory-path>                                output directory,
                                                            or '-' for stdout
                                                            (default: 'dump')
      --gzip                                                compress archive or
                                                            collection output
                                                            with Gzip
      --oplog                                               for taking a
                                                            point-in-time
                                                            snapshot on a
                                                            replica set that is
                                                            not part of a
                                                            sharded cluster.
      --archive=<file-path>                                 dump as an archive
                                                            to the specified
                                                            path. If flag is
                                                            specified without a
                                                            value, archive is
                                                            written to stdout
      --dumpDbUsersAndRoles                                 dump user and role
                                                            definitions for the
                                                            specified database
      --excludeCollection=<collection-name>                 collection to
                                                            exclude from the
                                                            dump (may be
                                                            specified multiple
                                                            times to exclude
                                                            additional
                                                            collections)
      --excludeCollectionsWithPrefix=<collection-prefix>    exclude all
                                                            collections from
                                                            the dump that have
                                                            the given prefix
                                                            (may be specified
                                                            multiple times to
                                                            exclude additional
                                                            prefixes)
  -j, --numParallelCollections=                             number of
                                                            collections to dump
                                                            in parallel
      --viewsAsCollections                                  dump views as
                                                            normal collections
                                                            with their produced
                                                            data, omitting
                                                            standard collections