This document provides a complete overview of all command line options
for mongod. These command line options are primarily useful
for testing: In common operation, use the configuration file
options to control the behavior of
your database.

Specifies a configuration file for runtime configuration options. The
configuration file is the preferred method for runtime configuration of
mongod. The options are equivalent to the command-line
configuration options. See Configuration File Options for
more information.

Ensure the configuration file uses ASCII encoding. The mongod
instance does not support configuration files with non-ASCII encoding,
including UTF-8.

The hostnames and/or IP addresses and/or full Unix domain socket
paths on which mongod should listen for client connections. You
may attach mongod to any interface. To bind to multiple
addresses, enter a list of comma-separated values.

Example

localhost,/tmp/mongod.sock

Tip

When possible, use a logical DNS hostname instead of an ip address,
particularly when configuring replica set members or sharded cluster
members. The use of logical DNS hostnames avoids configuration
changes due to ip address changes.

If specified, the mongod instance binds to all ip addresses. When
attaching mongod to a publicly accessible interface, ensure
that you have implemented proper authentication and firewall
restrictions to protect the integrity of your database.

Consult your local system’s documentation to understand the
limitations and configuration requirements before using this
parameter.

Important

To prevent undefined behavior, specify a value for this
parameter between 1 and the local system SOMAXCONN
constant.

The default value for the listenBacklog parameter is set at
compile time to the target system SOMAXCONN constant.
SOMAXCONN is the maximum valid value that is documented for
the backlog parameter to the listen system call.

Some systems may interpret SOMAXCONN symbolically, and others
numerically. The actual listen backlog applied in practice may
differ from any numeric interpretation of the SOMAXCONN constant
or argument to --listenBacklog, and may also be constrained by
system settings like net.core.somaxconn on Linux.

Passing a value for the listenBacklog parameter that exceeds the
SOMAXCONN constant for the local system is, by the letter of the
standards, undefined behavior. Higher values may be silently integer
truncated, may be ignored, may cause unexpected resource
consumption, or have other adverse consequences.

On systems with workloads that exhibit connection spikes, for which
it is empirically known that the local system can honor higher
values for the backlog parameter than the SOMAXCONN constant,
setting the listenBacklog parameter to a higher value may reduce
operation latency as observed by the client by reducing the number
of connections which are forced into a backoff state.

The syslog daemon generates timestamps when it logs a message, not
when MongoDB issues the message. This can lead to misleading timestamps
for log entries, especially when the system is under heavy load. We
recommend using the --logpath option for production systems to
ensure accurate timestamps.

Specifies the facility level used when logging messages to syslog.
The value you specify must be supported by your
operating system’s implementation of syslog. To use this option, you
must enable the --syslog option.

Specifies a file location to hold the process ID of the mongod
process where mongod will write its PID. This is useful for
tracking the mongod process in combination with
the --fork option. Without a specified --pidfilepath option, the
process creates no PID file.

Enables a daemon mode that runs the mongod process in the
background. By default mongod does not run as a daemon:
typically you will run mongod as a daemon, either by using
--fork or by using a controlling process that handles the
daemonization process (e.g. as with upstart and systemd).

Enables authorization to control user’s access to database resources
and operations. When authorization is enabled, MongoDB requires all
clients to authenticate themselves first in order to determine the
access for the client.

Configure users via the mongo shell. If no users exist, the localhost interface
will continue to have access to the database until you create
the first user.

New in version 3.4: Allows the mongod to accept and create authenticated and
non-authenticated connections to and from other mongod
and mongos instances in the deployment. Used for
performing rolling transition of replica sets or sharded clusters
from a no-auth configuration to internal authentication. Requires specifying a internal
authentication mechanism such as
--keyFile.

For example, if using keyfiles for
internal authentication, the mongod creates
an authenticated connection with any mongod or mongos
in the deployment using a matching keyfile. If the security mechanisms do
not match, the mongod utilizes a non-authenticated connection instead.

A mongod running with --transitionToAuth does not enforce user access
controls. Users may connect to your deployment without any
access control checks and perform read, write, and administrative operations.

A mongod running with --redactClientLogData redacts any message accompanying a given
log event before logging. This prevents the mongod from writing
potentially sensitive data stored on the database to the diagnostic log.
Metadata such as error or operation codes, line numbers, and source file
names are still visible in the logs.

For example, a MongoDB deployment might store Personally Identifiable
Information (PII) in one or more collections. The mongod logs events
such as those related to CRUD operations, sharding metadata, etc. It is
possible that the mongod may expose PII as a part of these logging
operations. A mongod running with --redactClientLogData removes any message
accompanying these events before being output to the log, effectively
removing the PII.

In versions 3.6 and 4.0, mongod and
mongos enable network compression by default with
snappy as the compressor.

To disable network compression, set the value to disabled.

Important

Messages are compressed when both parties enable network
compression. Otherwise, messages between the parties are
uncompressed.

If you specify multiple compressors, then the order in which you list
the compressors matter as well as the communication initiator. For
example, if a mongo shell specifies the following network
compressors zlib,snappy and the mongod specifies
snappy,zlib, messages between mongo shell and
mongod uses zlib.

If the parties do not share at least one common compressor, messages
between the parties are uncompressed. For example, if a
mongo shell specifies the network compressor
zlib and mongod specifies snappy, messages
between mongo shell and mongod are not compressed.

Determines the threading and execution model mongod uses to
execute client requests. The --serviceExecutor option accepts one
of the following values:

Value

Description

synchronous

The mongod uses synchronous networking and manages its
networking thread pool on a per connection basis. Previous
versions of MongoDB managed threads in this way.

adaptive

The mongod uses the new experimental asynchronous
networking mode with an adaptive thread pool which manages
threads on a per request basis. This mode should have more
consistent performance and use less resources when there are
more inactive connections than database requests.

The LDAP server against which the mongod executes LDAP operations
against to authenticate users or determine what actions a user is authorized
to perform on a given database. If the LDAP server specified has any
replicated instances, you may specify the host and port of each replicated
server in a comma-delimited list.

If your LDAP infrastrucure partitions the LDAP directory over multiple LDAP
servers, specify one LDAP server any of its replicated instances to
--ldapServers. MongoDB supports following LDAP referrals as defined in RFC 4511
4.1.10. Do not use --ldapServers
for listing every LDAP server in your infrastucture.

This setting can be configured on a running mongod using
setParameter.

A comma-separated list of SASL mechanisms mongod can
use when authenticating to the LDAP server. The mongod and the
LDAP server must agree on at least one mechanism. The mongod
dynamically loads any SASL mechanism libraries installed on the host
machine at runtime.

Install and configure the appropriate libraries for the selected
SASL mechanism(s) on both the mongod host and the remote
LDAP server host. Your operating system may include certain SASL
libraries by default. Defer to the documentation associated with each
SASL mechanism for guidance on installation and configuration.

If using the GSSAPI SASL mechanism for use with
Kerberos Authentication, verify the following for the
mongod host machine:

Linux

The KRB5_CLIENT_KTNAME environment
variable resolves to the name of the client Linux Keytab Files
for the host machine. For more on Kerberos environment
variables, please defer to the
Kerberos documentation.

The client keytab includes a
User Principal for the mongod to use when
connecting to the LDAP server and execute LDAP queries.

Windows

If connecting to an Active Directory server, the Windows
Kerberos configuration automatically generates a
Ticket-Granting-Ticket
when the user logs onto the system. Set --ldapBindWithOSDefaults to
true to allow mongod to use the generated credentials when
connecting to the Active Directory server and execute queries.

For a complete list of SASL mechanisms see the
IANA listing.
Defer to the documentation for your LDAP or Active Directory
service for identifying the SASL mechanisms compatible with the
service.

MongoDB is not a source of SASL mechanism libraries, nor
is the MongoDB documentation a definitive source for
installing or configuring any given SASL mechanism. For
documentation and support, defer to the SASL mechanism
library vendor or owner.

By default, mongod creates a TLS/SSL secured connection to the LDAP
server.

For Linux deployments, you must configure the appropriate TLS Options in
/etc/openldap/ldap.conf file. Your operating system’s package manager
creates this file as part of the MongoDB Enterprise installation, via the
libldap dependency. See the documentation for TLSOptions in the
ldap.conf OpenLDAP documentation
for more complete instructions.

For Windows deployment, you must add the LDAP server CA certificates to the
Windows certificate management tool. The exact name and functionality of the
tool may vary depending on operating system version. Please see the
documentation for your version of Windows for more information on
certificate management.

The amount of time in milliseconds mongod should wait for an LDAP server
to respond to a request.

Increasing the value of --ldapTimeoutMS may prevent connection failure between the
MongoDB server and the LDAP server, if the source of the failure is a
connection timeout. Decreasing the value of --ldapTimeoutMS reduces the time
MongoDB waits for a response from the LDAP server.

This setting can be configured on a running mongod using
setParameter.

Transforming the usernames of clients authenticating to Mongo DB using
different authentication mechanisms (e.g. x.509, kerberos) to a full LDAP
DN for authorization.

--ldapUserToDNMapping expects a quote-enclosed JSON-string representing an ordered array
of documents. Each document contains a regular expression match and
either a substitution or ldapQuery template used for transforming the
incoming username.

An ECMAScript-formatted regular expression (regex) to match against a
provided username. Each parenthesis-enclosed section represents a
regex capture group used by substitution or ldapQuery.

"(.+)ENGINEERING""(.+)DBA"

substitution

An LDAP distinguished name (DN) formatting template that converts the
authentication name matched by the match regex into a LDAP DN.
Each curly bracket-enclosed numeric value is replaced by the
corresponding regex capture group extracted
from the authentication username via the match regex.

A LDAP query formatting template that inserts the authentication
name matched by the match regex into an LDAP query URI encoded
respecting RFC4515 and RFC4516. Each curly bracket-enclosed numeric
value is replaced by the corresponding regex capture group extracted
from the authentication username via the match expression.
mongod executes the query against the LDAP server to retrieve
the LDAP DN for the authenticated user. mongod requires
exactly one returned result for the transformation to be
successful, or mongod skips this transformation.

"ou=engineering,dc=example,dc=com??one?(user={0})"

Note

An explanation of RFC4514,
RFC4515,
RFC4516, or LDAP queries is out
of scope for the MongoDB Documentation. Please review the RFC directly or
use your preferred LDAP resource.

For each document in the array, you must use either substitution or
ldapQuery. You cannot specify both in the same document.

When performing authentication or authorization, mongod steps through
each document in the array in the given order, checking the authentication
username against the match filter. If a match is found,
mongod applies the transformation and uses the output for
authenticating the user. mongod does not check the remaining documents
in the array.

If the given document does not match the provided authentication name, or
the transformation described by the document fails, mongod continues
through the list of documents to find additional matches. If no matches are
found in any document, mongod returns an error.

Example

The following shows two transformation documents. The first
document matches against any string ending in @ENGINEERING, placing
anything preceeding the suffix into a regex capture group. The
second document matches against any string ending in @DBA, placing
anything preceeding the suffix into a regex capture group.

A user with username alice@ENGINEERING.EXAMPLE.COM matches the first
document. The regex capture group {0} corresponds to the string
alice. The resulting output is the DN
"cn=alice,ou=engineering,dc=example,dc=com".

A user with username bob@DBA.EXAMPLE.COM matches the second document.
The regex capture group {0} corresponds to the string bob. The
resulting output is the LDAP query
"ou=dba,dc=example,dc=com??one?(user=bob)". mongod executes this
query against the LDAP server, returning the result
"cn=bob,ou=dba,dc=example,dc=com".

If --ldapUserToDNMapping is unset, mongod applies no transformations to the username
when attempting to authenticate or authorize a user against the LDAP server.

This setting can be configured on a running mongod using the
setParameter database command.

A relative LDAP query URL formatted conforming to RFC4515 and RFC4516 that mongod executes to obtain
the LDAP groups to which the authenticated user belongs to. The query is
relative to the host or hosts specified in --ldapServers.

Use the {USER} placeholder in the URL to substitute the authenticated
username, or the transformed username if a usernamemapping is specified.

When constructing the query URL, ensure that the order of LDAP parameters
respects RFC4516:

If your query includes an attribute, mongod assumes that the query
retrieves a the DNs which this entity is member of.

If your query does not include an attribute, mongod assumes
the query retrieves all entities which the user is member of.

For each LDAP DN returned by the query, mongod assigns the authorized
user a corresponding role on the admin database. If a role on the on the
admin database exactly matches the DN, mongod grants the user the
roles and privileges assigned to that role. See the
db.createRole() method for more information on creating roles.

Your LDAP configuration may not include the memberOf attribute as part
of the user schema, may possess a different attribute for reporting group
membership, or may not track group membership through attributes.
Configure your query with respect to your own unique LDAP configuration.

If unset, mongod cannot authorize users using LDAP.

This setting can be configured on a running mongod using the
setParameter database command.

Note

An explanation of RFC4515,
RFC4516 or LDAP queries is out
of scope for the MongoDB Documentation. Please review the RFC directly or
use your preferred LDAP resource.

For standalone instances, you can use mongodump on
the existing instance, stop the instance, restart with the new
--directoryperdb value and a new data directory, and use
mongorestore to populate the new data directory.

For replica sets, you can update in a rolling manner by stopping
a secondary member, restart with the new --directoryperdb value and
a new data directory, and use initial sync to populate the new data directory.
To update all members, start with the secondary members first.
Then step down the primary, and update the stepped-down member.

Stops the mongodstandalone instance from rebuilding incomplete indexes on the next
start up. This applies in cases where the mongod restarts after it
has shut down or stopped in the middle of an index build. In such cases,
the mongod always removes any incomplete indexes, and then also, by
default, attempts to rebuild them. To stop the mongod from
rebuilding incomplete indexes on start up, include this option on the
command-line.

Specifies the default size for namespace files, which are files that end
in .ns. Each collection and index counts as a namespace.

Use this setting to control size for newly created namespace files. This
option has no impact on existing files. The maximum size for a namespace
file is 2047 megabytes. The default value of 16 megabytes provides for
approximately 24,000 namespaces.

Sets MongoDB to use a smaller default file size. The --smallfiles option
reduces the initial size for data files and limits the maximum size to
512 megabytes. --smallfiles also reduces the size of each journal
file from 1 gigabyte to 128 megabytes. Use --smallfiles if you have a large
number of databases that each holds a small quantity of data.

The --smallfiles option can lead the mongod instance to create a large
number of files, which can affect performance for larger databases.

Controls how much time can pass before MongoDB flushes data to the data
files via an fsync operation.

Do not set this value on
production systems. In almost every situation, you should use the
default setting.

Warning

If you set --syncdelay to 0, MongoDB will not sync the
memory mapped files to disk.

The mongod process writes data very quickly to the journal and
lazily to the data files. --syncdelay has no effect on the
journal files or journaling,
but if --syncdelay is set to 0 the journal will eventually consume
all available disk space. If you set --syncdelay to 0 for testing
purposes, you should also set --nojournal
to true.

Runs a repair routine on all databases for a mongod
instance. The operation attempts to salvage corrupt data as well as
rebuilds all the indexes. The operation discards any corrupt data
that cannot be salvaged.

Tip

If you are running with journaling enabled, there is
almost never any need to run repair since the server can use the
journal files to restore the data files to a clean state automatically.
However, you may need to run repair in cases where you need to recover
from a disk-level data corruption.

If you do choose to run mongod--repair against a
replica set member and the operation modifies the data or the
metadata, you must still perform a full resync in order for the
member to rejoin the replica set.

The maximum amount of time in milliseconds that
the mongod process allows between
journal operations. Values can range from 1 to 500 milliseconds. Lower
values increase the durability of the journal, at the expense of disk
performance. The default journal commit interval is 100 milliseconds.

On MMAPv1, if the journal is on a different block device (e.g. physical
volume, RAID device, or LVM volume) than the data files, the default journal
commit interval is 30 milliseconds. Additionally, on MMAPv1, when a write
operation with j:true is pending, mongod will reduce
commitIntervalMs to a third of the set value.

On WiredTiger, the default journal commit interval is 100 milliseconds. Additionally,
a write with j:true will cause an immediate sync of the journal.

Defines the maximum size of the internal cache that WiredTiger will
use for all data.

Changed in version 3.4: Values can range from 256MB to 10TB and can be a float. In
addition, the default value has also changed.

Starting in 3.4, the WiredTiger internal cache, by default, will use
the larger of either:

50% of (RAM - 1 GB), or

256 MB.

For example, on a system with a total of 4GB of RAM the WiredTiger
cache will use 1.5GB of RAM (0.5*(4GB-1GB)=1.5GB).
Conversely, a system with a total of 1.25 GB of RAM will allocate 256
MB to the WiredTiger cache because that is more than half of the
total RAM minus one gigabyte (0.5*(1.25GB-1GB)=128MB<256MB).

With WiredTiger, MongoDB utilizes both the WiredTiger internal cache
and the filesystem cache.

Via the filesystem cache, MongoDB automatically uses all free memory
that is not used by the WiredTiger cache or by other processes.

Note

The --wiredTigerCacheSizeGB limits the size of the WiredTiger internal
cache. The operating system will use the available free memory
for filesystem cache, which allows the compressed MongoDB data
files to stay in memory. In addition, the operating system will
use any free RAM to buffer file system blocks and file system
cache.

To accommodate the additional consumers of RAM, you may have to
decrease WiredTiger internal cache size.

The default WiredTiger internal cache size value assumes that there is a
single mongod instance per machine. If a single machine
contains multiple MongoDB instances, then you should decrease the setting to
accommodate the other mongod
instances.

If you run mongod in a container (e.g. lxc,
cgroups, Docker, etc.) that does not have access to all of the
RAM available in a system, you must set --wiredTigerCacheSizeGB to a value less
than the amount of RAM available in the container. The exact amount
depends on the other processes running in the container.

When you start mongod with --wiredTigerDirectoryForIndexes, mongod stores indexes and collections in separate
subdirectories under the data (i.e. --dbpath) directory.
Specifically, mongod stores the indexes in a subdirectory named
index and the collection data in a subdirectory named
collection.

By using a symbolic link, you can specify a different location for
the indexes. Specifically, when mongod instance is not
running, move the index subdirectory to the destination and
create a symbolic link named index under the data directory to
the new destination.

Specifies a maximum size in megabytes for the replication operation log
(i.e., the oplog).

Note

Starting in MongoDB 4.0, the oplog can grow past its configured size
limit to avoid deleting the majoritycommitpoint.

By default, the mongod process creates an oplog based on
the maximum amount of space available. For 64-bit systems, the oplog
is typically 5% of available disk space.

Once the mongod has created the oplog for the first time,
changing the --oplogSize option will not affect the size of the oplog.

To change the oplog size of a running replica set member, use the
replSetResizeOplog administrative command.
replSetResizeOplog enables you to resize the oplog
dynamically without restarting the mongod process.

Determines which indexes secondary members of a replica
set load into memory before applying operations from the oplog. By
default secondaries load all indexes related to an operation into memory
before applying operations from the oplog.

Starting in MongoDB 3.6, MongoDB enables support for
"majority" read concern by default.

For MongoDB 4.0.3+ and 3.6.1+, you can disable read concern
"majority" to prevent the storage cache pressure from
immobilizing a deployment with a three-member
primary-secondary-arbiter (PSA) architecture. For more information
about disabling read concern "majority", see
Disable Read Concern Majority.

In general, avoid disabling "majority" read concern
unless necessary. However, if you have a three-member replica set
with a primary-secondary-arbiter (PSA) architecture or a sharded
cluster with a three-member PSA shards, disable to prevent the
storage cache pressure from immobilizing the deployment.

Declares that this mongod instance serves as the config
server of a sharded cluster. When
running with this option, clients (i.e. other cluster components)
cannot write data to any database other than config
and admin. The default port for a mongod with this option is
27019 and the default --dbpath directory is
/data/configdb, unless specified.

Important

Starting in 3.4, you must deploy config servers as a replica set.
The use of the deprecated mirrored mongod instances as
config servers (SCCC) is no longer supported.

If set to sccc, indicates that the config servers are deployed
as three mirrored mongod instances, even if one or more
config servers is also a member of a replica set. configsvrMode
only accepts the value sccc.

If unset, config servers running as replica sets expect to use the
“config server replica set” protocol for writing to config servers,
rather than the “mirrored mongod” write protocol.

Enables TLS/SSL or mixed TLS/SSL used for all network connections. The
argument to the --sslMode option can be one of the following:

Value

Description

disabled

The server does not use TLS/SSL.

allowSSL

Connections between servers do not use TLS/SSL. For incoming
connections, the server accepts both TLS/SSL and non-TLS/non-SSL.

preferSSL

Connections between servers use TLS/SSL. For incoming
connections, the server accepts both TLS/SSL and non-TLS/non-SSL.

requireSSL

The server uses and accepts only TLS/SSL encrypted connections.

Starting in version 3.4, if --sslCAFile or ssl.CAFile is not
specified and you are not using x.509 authentication, the
system-wide CA certificate store will be used when connecting to an
TLS/SSL-enabled server.

Specifies the password to de-crypt the certificate-key file (i.e.
--sslPEMKeyFile). Use the --sslPEMKeyPassword option only if the
certificate-key file is encrypted. In all cases, the mongod will
redact the password from all logging and reporting output.

On macOS or Windows, if the private key in the PEM file is
encrypted, you must explicitly specify the --sslPEMKeyPassword option.
Alternatively, you can use a certificate from the secure system
store (see --sslCertificateSelector) instead of a PEM key file or use an
unencrypted PEM file.

The authentication mode used for cluster authentication. If you use
internal x.509 authentication,
specify so here. This option can have one of the following values:

Value

Description

keyFile

Use a keyfile for authentication.
Accept only keyfiles.

sendKeyFile

For rolling upgrade purposes. Send a keyfile for
authentication but can accept both keyfiles and x.509
certificates.

sendX509

For rolling upgrade purposes. Send the x.509 certificate for
authentication but can accept both keyfiles and x.509
certificates.

x509

Recommended. Send the x.509 certificate for authentication and
accept only x.509 certificates.

Starting in version 3.4, if --sslCAFile or ssl.CAFile is not
specified and you are not using x.509 authentication, the
system-wide CA certificate store will be used when connecting to an
TLS/SSL-enabled server.

Specifies the password to de-crypt the x.509 certificate-key file
specified with --sslClusterFile. Use the --sslClusterPassword option only
if the certificate-key file is encrypted. In all cases, the mongod
will redact the password from all logging and reporting output.

On macOS or Windows, if the private key in the x.509 file is
encrypted, you must explicitly specify the --sslClusterPassword option.
Alternatively, you can either use a certificate from the secure
system store (see --sslClusterCertificateSelector) instead of a cluster PEM file or
use an unencrypted PEM file.

Specifies the .pem file that contains the root certificate chain
from the Certificate Authority. Specify the file name of the
.pem file using relative or absolute paths.

Starting in 4.0, on macOS or Windows, you can use a certificate from
the operating system’s secure store instead of a PEM key file. See
--sslCertificateSelector. When using the secure store, you
do not need to, but can, also specify the --sslCAFile.

Specifies the .pem file that contains the root certificate chain
from the Certificate Authority used to validate the certificate
presented by a client establishing a connection. Specify the file
name of the .pem file using relative or absolute paths.

If --sslClusterCAFile does not specify the .pem file for validating the
certificate from a client establishing a connection, the cluster uses
the .pem file specified in the --sslCAFile option.

--sslClusterCAFile lets you use separate Certificate Authorities to verify the
client to server and server to client portions of the TLS handshake.

Starting in 4.0, on macOS or Windows, you can use a certificate from
the operating system’s secure store instead of a PEM key file. See
--sslClusterCertificateSelector. When using the secure store, you
do not need to, but can, also specify the --sslClusterCAFile.

Bypasses the validation checks for TLS/SSL certificates on other
servers in the cluster and allows the use of invalid certificates to
connect.

Note

Starting in MongoDB 4.0, if you specify
--sslAllowInvalidCertificates or ssl.allowInvalidCertificates:true when using x.509 authentication, an invalid certificate is
only sufficient to establish a TLS/SSL connection but is
insufficient for authentication.

Disables the validation of the hostnames in TLS/SSL certificates,
when connecting to other members of the replica set or sharded cluster
for inter-process authentication. This allows mongod to connect
to other members if the hostnames in their certificates do not match
their configured hostname.

The profiler is off and does not collect any data.
This is the default profiler level.

1

The profiler collects data for operations that take longer
than the value of slowms.

2

The profiler collects data for all operations.

Important

Profiling can impact performance and shares settings with the system
log. Carefully consider any performance and security implications
before configuring and enabling the profiler on a production
deployment.

The slow operation time threshold, in milliseconds. Operations
that run for longer than this threshold are considered slow.

When logLevel is set to 0, MongoDB
records slow operations to the diagnostic log at a rate determined by
slowOpSampleRate. At higher
logLevel settings, all operations appear in the diagnostic
log regardless of their latency.

For mongod instances, --slowms affects the diagnostic log
and, if enabled, the profiler.

The path to the local keyfile when managing keys via process other
than KMIP. Only set when managing keys via process other than KMIP.
If data is already encrypted using KMIP, MongoDB will throw an error.

Unique KMIP identifier for an existing key within the KMIP server.
Include to use the key associated with the identifier as the system
key. You can only use the setting the first time you enable
encryption for the mongod instance. Requires
enableEncryption to be true.

If unspecified, MongoDB will request that the KMIP server create a
new key to utilize as the system key.

If the KMIP server cannot locate a key with the specified identifier
or the data is already encrypted with a key, MongoDB will throw an
error

When connecting to the KMIP server, the mongod
verifies that the specified --kmipServerName matches the Subject Alternative
Name SAN (or, if SAN is not present, the Common Name CN)
in the certificate presented by the KMIP server. If SAN is
present, mongod does not match against the CN. If
the hostname does not match the SAN (or CN), the
mongod will fail to connect.

The password (if one exists) for the client certificate passed into
kmipClientCertificateFile. Is used for
authenticating MongoDB to the KMIP server. Requires that a
kmipClientCertificateFile be provided.

Path to CA File. Used for validating secure client connection to
KMIP server.

Note

Starting in 4.0, on macOS or Windows, you can use a certificate
from the operating system’s secure store instead of a PEM key
file. See --kmipClientCertificateSelector. When using the secure store, you do not
need to, but can, also specify the --kmipServerCAFile.