Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
mongod(1)		    General Commands Manual		     mongod(1)

MONGOD
SYNOPSIS
       mongod is the primary daemon process for	the MongoDB system. It handles
       data  requests, manages data access, and	performs background management
       operations.

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

       Configuration File Settings and Command-Line Options Mapping

       MongoDB disables	support	for TLS	1.0 encryption on  systems  where  TLS
       1.1+ is available.

COMPATIBILITY
       Deployments hosted in the following environments	use mongod:

	      	MongoDB		Atlas	     (https://www.mongodb.com/docs/at-
		las?tck=docs_server): The fully	managed	 service  for  MongoDB
		deployments in the cloud

       MongoDB Atlas manages the mongod	for all	MongoDB	Atlas deployments.

	      	MongoDB	 Enterprise: The subscription-based, self-managed ver-
		sion of	MongoDB

	      	MongoDB	 Community:  The  source-available,  free-to-use,  and
		self-managed version of	MongoDB

CONSIDERATIONS
	      	mongod	includes a Full	Time Diagnostic	Data Capture mechanism
		to assist MongoDB engineers with troubleshooting  deployments.
		If  this  thread fails,	it terminates the originating process.
		To avoid the most common failures, confirm that	the user  run-
		ning  the  process has permissions to create the FTDC diagnos-
		tic.data directory. For	mongod the directory is	 within	 stor-
		age.dbPath. For	mongos it is parallel to systemLog.path.

OPTIONS
	      	MongoDB	 always	 enables  journaling. As a result, MongoDB re-
		moves the storage.journal.enabled option and the corresponding
		--journal and --nojournal command-line options.

	      	MongoDB	removes	the --cpu command-line option.

	      	MongoDB	removes	the --serviceExecutor command-line option  and
		the corresponding net.serviceExecutor configuration option.

   CORE	OPTIONS
       mongod --help, mongod -h

	      Returns information on the options and use of mongod.

       mongod --version

	      Returns the mongod release number.

       mongod --config,	mongod -f

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

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

       mongod --configExpand

	      Default: none

	      Enables using Expansion Directives in configuration  files.  Ex-
	      pansion  directives  allow  you to set externally	sourced	values
	      for configuration	file options.

	      --configExpand supports the following expansion directives:

		     

		          Value

		          Description

		     

		          none

		          Default. mongod does	not  expand  expansion	direc-
			   tives.   mongod fails to start if any configuration
			   file	settings use expansion directives.

		     

		          rest

		          mongod expands  __rest  expansion  directives  when
			   parsing the configuration file.

		     

		          exec

		          mongod  expands  __exec  expansion  directives when
			   parsing the configuration file.

	      You can specify multiple expansion directives as	a  comma-sepa-
	      rated  list,  for	example: rest, exec. If	the configuration file
	      contains expansion directives not	specified  to  --configExpand,
	      the mongod returns an error and terminates.

	      See  Externally Sourced Configuration File Values	for configura-
	      tion files for more information on expansion directives.

       mongod --verbose, mongod	-v

	      Increases	the amount of internal reporting returned on  standard
	      output  or in log	files. Increase	the verbosity with the -v form
	      by including the option multiple times, for example: -vvvvv.

	      Starting in version 4.2, MongoDB includes	 the  Debug  verbosity
	      level  (1-5)  in the log messages. For example, if the verbosity
	      level is 2, MongoDB logs D2. In previous versions,  MongoDB  log
	      messages only specified D	for Debug level.

       mongod --quiet

	      Runs mongod in a quiet mode that attempts	to limit the amount of
	      output.

	      This option suppresses:

		      output from database commands

		      replication activity

		      connection accepted events

		      connection closed events

       mongod --port

	      Default:

		      27017  if  mongod  is  not  a  shard member or a	config
		       server member

		      27018 if	mongod is a shard member

		      27019 if	mongod is a config server member

	      The TCP port on which the	MongoDB	instance  listens  for	client
	      connections.

	      The --port option	accepts	a range	of values between 0 and	65535.
	      Setting the port to 0 configures mongod to use an	arbitrary port
	      assigned by the operating	system.

       mongod --bind_ip

	      Default: localhost

	      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  ad-
	      dresses, enter a list of comma-separated values.

	      You  can specify both IPv4 and IPv6 addresses, or	hostnames that
	      resolve to an IPv4 or IPv6 address.

	      If specifying an IPv6 address or a hostname that resolves	to  an
	      IPv6  address to --bind_ip, you must start mongod	with --ipv6 to
	      enable IPv6 support. Specifying an  IPv6	address	 to  --bind_ip
	      does not enable IPv6 support.

	      If      specifying      a	     link-local	     IPv6      address
	      (https://en.wikipedia.org/wiki/Link-local_address#IPv6)
	      (fe80::/10),    you    must    append	the	zone	 index
	      (https://en.wikipedia.org/wiki/IPv6_address#Scoped_lit-
	      eral_IPv6_addresses_(with_zone_index))  to  that	address	 (i.e.
	      fe80::<address>%<adapter-name>).

	      To avoid configuration updates due to IP	address	 changes,  use
	      DNS hostnames instead of IP addresses. It	is particularly	impor-
	      tant to use a DNS	hostname instead of an IP address when config-
	      uring replica set	members	or sharded cluster members.

	      Use  hostnames  instead  of  IP  addresses to configure clusters
	      across a split network horizon. Starting in MongoDB  5.0,	 nodes
	      that are only configured with an IP address fail startup valida-
	      tion and do not start.

	      Before  you  bind	 your instance to a publicly-accessible	IP ad-
	      dress, you must secure your cluster  from	 unauthorized  access.
	      For  a  complete	list of	security recommendations, see Security
	      Checklist. At  minimum,  consider	 enabling  authentication  and
	      hardening	network	infrastructure.

	      For  more	 information about IP Binding, refer to	the IP Binding
	      documentation.

	      To bind to all IPv4 addresses, enter 0.0.0.0.

	      To bind to all IPv4 and IPv6 addresses, enter ::,0.0.0.0	or  an
	      asterisk	"*"  (enclose the asterisk in quotes to	avoid filename
	      pattern expansion). Alternatively, use  the  net.bindIpAll  set-
	      ting.

		      --bind_ip  and  --bind_ip_all  are  mutually exclusive.
		       Specifying both options causes mongod to	throw an error
		       and terminate.

		      The command-line	option --bind overrides	the configura-
		       tion file setting net.bindIp.

       mongod --bind_ip_all

	      If specified, the	mongod instance	binds to  all  IPv4  addresses
	      (i.e. 0.0.0.0). If mongod	starts with --ipv6, --bind_ip_all also
	      binds to all IPv6	addresses (i.e.	::).

	      mongod  only  supports  IPv6  if started with --ipv6. Specifying
	      --bind_ip_all alone does not enable IPv6 support.

	      Before you bind your instance to a  publicly-accessible  IP  ad-
	      dress,  you  must	 secure	your cluster from unauthorized access.
	      For a complete list of security  recommendations,	 see  Security
	      Checklist.  At  minimum,	consider  enabling  authentication and
	      hardening	network	infrastructure.

	      For more information about IP Binding, refer to the  IP  Binding
	      documentation.

	      Alternatively, you can set the --bind_ip option to ::,0.0.0.0 or
	      to  an  asterisk	"*"  (enclose  the asterisk in quotes to avoid
	      filename pattern expansion).

	      --bind_ip	and --bind_ip_all are mutually exclusive. That is, you
	      can specify one or the other, but	not both.

       mongod --clusterIpSourceAllowlist

	      A	list of	 IP  addresses/CIDR  (Classless	 Inter-Domain  Routing
	      (https://tools.ietf.org/html/rfc4632))  ranges against which the
	      mongod validates authentication requests from other  members  of
	      the  replica  set	 and, if part of a sharded cluster, the	mongos
	      instances. The mongod verifies that the originating IP is	either
	      explicitly in the	list or	belongs	to a CIDR range	in  the	 list.
	      If  the IP address is not	present, the server does not authenti-
	      cate the mongod or mongos.

	      --clusterIpSourceAllowlist has no	effect	on  a  mongod  started
	      without authentication.

	      --clusterIpSourceAllowlist   accepts   multiple  comma-separated
	      IPv4/6  addresses	 or  Classless	Inter-Domain   Routing	 (CIDR
	      (https://tools.ietf.org/html/rfc4632)) ranges:

		mongod --clusterIpSourceAllowlist 192.0.2.0/24,127.0.0.1,::1

	      Ensure  --clusterIpSourceAllowlist  includes  the	 IP address or
	      CIDR ranges that include the IP address of each replica set mem-
	      ber or mongos in the deployment to ensure	healthy	 communication
	      between cluster components.

       mongod --clusterIpSourceWhitelist

	      Deprecated  in  version  5.0: Use	--clusterIpSourceAllowlist in-
	      stead.

	      A	list of	 IP  addresses/CIDR  (Classless	 Inter-Domain  Routing
	      (https://tools.ietf.org/html/rfc4632))  ranges against which the
	      mongod validates authentication requests from other  members  of
	      the  replica  set	 and, if part of a sharded cluster, the	mongos
	      instances. The mongod verifies that the originating IP is	either
	      explicitly in the	list or	belongs	to a CIDR range	in  the	 list.
	      If  the IP address is not	present, the server does not authenti-
	      cate the mongod or mongos.

	      --clusterIpSourceWhitelist has no	effect	on  a  mongod  started
	      without authentication.

	      --clusterIpSourceWhitelist   accepts   multiple  comma-separated
	      IPv4/6  addresses	 or  Classless	Inter-Domain   Routing	 (CIDR
	      (https://tools.ietf.org/html/rfc4632)) ranges:

		mongod --clusterIpSourceWhitelist 192.0.2.0/24,127.0.0.1,::1

	      Ensure  --clusterIpSourceWhitelist  includes  the	 IP address or
	      CIDR ranges that include the IP address of each replica set mem-
	      ber or mongos in the deployment to ensure	healthy	 communication
	      between cluster components.

       mongod --ipv6

	      Enables IPv6 support. mongod disables IPv6 support by default.

	      Setting --ipv6 does not direct the mongod	to listen on any local
	      IPv6  addresses or interfaces. To	configure the mongod to	listen
	      on an IPv6 interface, you	must either:

		      Configure --bind_ip with	one or more IPv6 addresses  or
		       hostnames that resolve to IPv6 addresses, or

		      Set --bind_ip_all to true.

       mongod --listenBacklog

	      Default: Target system SOMAXCONN constant

	      The  maximum  number of connections that can exist in the	listen
	      queue.

	      Consult your local system's documentation	to understand the lim-
	      itations and configuration requirements before using this	 para-
	      meter.

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

	      The default value	for the	listenBacklog parameter	is set at com-
	      pile time	to the target system SOMAXCONN constant.  SOMAXCONN is
	      the maximum valid	value that is documented for the backlog para-
	      meter 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 in-
	      teger  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  con-
	      stant, 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.

       mongod --maxConns

	      The maximum number of simultaneous connections that  mongod  ac-
	      cepts.  This setting has no effect if it is higher than your op-
	      erating system's configured maximum connection tracking  thresh-
	      old.

	      Do not assign too	low of a value to this option, or you will en-
	      counter errors during normal application operation.

       mongod --logpath

	      Sends  all  diagnostic logging information to a log file instead
	      of to standard output or to the host's  syslog  system.  MongoDB
	      creates the log file at the path you specify.

	      By  default,  MongoDB  moves  any	 existing log file rather than
	      overwriting it. To instead append	to the log file, set the --lo-
	      gappend option.

       mongod --syslog

	      Sends all	logging	output to the host's syslog system rather than
	      to standard output or to a log file (--logpath).

	      The --syslog option is not supported on Windows.

	      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  produc-
	      tion systems to ensure accurate timestamps.

	      MongoDB includes the component in	its log	messages to syslog.

		...  ACCESS   [repl writer worker 5] Unsupported modification to roles collection ...

       mongod --syslogFacility

	      Default: user

	      Specifies	 the facility level used when logging messages to sys-
	      log.  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.

       mongod --logappend

	      Appends new entries to the end of	the existing log file when the
	      mongod instance restarts.	Without	this option, mongod  backs  up
	      the existing log and create a new	file.

       mongod --logRotate

	      Default: rename

	      Determines  the behavior for the logRotate command when rotating
	      the server log and/or the	audit log. Specify  either  rename  or
	      reopen:

		      rename renames the log file.

		      reopen  closes  and  reopens the	log file following the
		       typical Linux/Unix log rotate behavior. Use reopen when
		       using the Linux/Unix logrotate  utility	to  avoid  log
		       loss.

		       If you specify reopen, you must also use	--logappend.

       mongod --timeStampFormat

	      Default: iso8601-local

	      The  time	 format	for timestamps in log messages.	Specify	one of
	      the following values:

		     

		          Value

		          Description

		     

		          iso8601-utc

		          Displays timestamps in Coordinated  Universal  Time
			   (UTC)  in the ISO-8601 format. For example, for New
			   York	   at	 the	start	 of	the	Epoch:
			   1970-01-01T00:00:00.000Z

		     

		          iso8601-local

		          Displays  timestamps	 in local time in the ISO-8601
			   format. For example,	for New	York at	the  start  of
			   the Epoch: 1969-12-31T19:00:00.000-05:00

	      --timeStampFormat	 no longer supports ctime. An example of ctime
	      formatted	date is: Wed Dec 31 18:17:54.811.

       mongod --traceExceptions

	      For internal diagnostic use only.

       mongod --pidfilepath

	      Specifies	a file location	to store the process ID	(PID)  of  the
	      mongod  process.	The  user running the mongod or	mongos process
	      must be able to write to this path. If the --pidfilepath	option
	      is  not  specified, the process does not create a	PID file. This
	      option is	generally only useful in combination with  the	--fork
	      option.

	      On Linux,	PID file management is generally the responsibility of
	      your  distro's  init  system:  usually  a	 service  file	in the
	      /etc/init.d directory, or	a systemd unit	file  registered  with
	      systemctl.  Only use the --pidfilepath option if you are not us-
	      ing one of these init systems. For more information, please  see
	      the respective Installation Guide	for your operating system.

	      On macOS,	PID file management is generally handled by brew. Only
	      use  the	--pidfilepath option if	you are	not using brew on your
	      macOS system.  For more information, please see  the  respective
	      Installation Guide for your operating system.

       mongod --keyFile

	      Specifies	 the  path to a	key file that stores the shared	secret
	      that MongoDB instances use to authenticate to each  other	 in  a
	      sharded  cluster	or  replica set. --keyFile implies --auth. See
	      Internal/Membership Authentication for more information.

	      Keyfiles for internal membership authentication use YAML	format
	      to allow for multiple keys in a keyfile. The YAML	format accepts
	      either:

		      A single	key string (same as in earlier versions)

		      A sequence of key strings

	      The  YAML	format is compatible with the existing single-key key-
	      files that use the text file format.

       mongod --setParameter

	      Specifies	one of the MongoDB  parameters	described  in  MongoDB
	      Server Parameters. You can specify multiple setParameter fields.

       mongod --nounixsocket

	      Disables listening on the	UNIX domain socket. --nounixsocket ap-
	      plies only to Unix-based systems.

	      The  mongod process always listens on the	UNIX socket unless one
	      of the following is true:

		      --nounixsocket is set

		      net.bindIp is not set

		      net.bindIp does not specify localhost or	its associated
		       IP address

	      mongod installed from official .deb and .rpm packages  have  the
	      bind_ip configuration set	to 127.0.0.1 by	default.

       mongod --unixSocketPrefix

	      Default: /tmp

	      The path for the UNIX socket. --unixSocketPrefix applies only to
	      Unix-based systems.

	      If this option has no value, the mongod process creates a	socket
	      with  /tmp  as  a	 prefix. MongoDB creates and listens on	a UNIX
	      socket unless one	of the following is true:

		      net.unixDomainSocket.enabled is false

		      --nounixsocket is set

		      net.bindIp is not set

		      net.bindIp does not specify localhost or	its associated
		       IP address

       mongod --filePermissions

	      Default: 0700

	      Sets the permission for the UNIX domain socket file.

	      --filePermissions	applies	only to	Unix-based systems.

       mongod --fork

	      Enables a	daemon mode that runs the mongod process in the	 back-
	      ground. The --fork option	is not supported on Windows.

	      By  default mongod does not run as a daemon. You run mongod as a
	      daemon by	using either --fork or a controlling process that han-
	      dles daemonization, such as upstart or systemd.

	      To use --fork, configure log output for the mongod with  one  of
	      the following:

		      --logpath

		      --syslog

       mongod --auth

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

	      To configure users, use the mongosh client. If no	 users	exist,
	      the  localhost  interface	 has  access to	the database until you
	      create the first user.

	      See Security for more information.

       mongod --noauth

	      Disables authentication. Currently the default. Exists  for  fu-
	      ture compatibility and clarity.

       mongod --transitionToAuth

	      Allows the mongod	to accept and create authenticated and non-au-
	      thenticated  connections to and from other mongod	and mongos in-
	      stances in the deployment. Used for performing  rolling  transi-
	      tion of replica sets or sharded clusters from a no-auth configu-
	      ration  to internal authentication. Requires specifying a	inter-
	      nal 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	 secu-
	      rity  mechanisms do not match, the mongod	utilizes a non-authen-
	      ticated 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  adminis-
	      trative operations.

	      A	 mongod	 running  with	internal  authentication  and  without
	      --transitionToAuth requires clients to connect using user	access
	      controls.	Update clients to connect to the mongod	using the  ap-
	      propriate	 user prior to restarting mongod without --transition-
	      ToAuth.

       mongod --sysinfo

	      Returns diagnostic system	information and	then exits. The	infor-
	      mation provides the page size, the number	of physical pages, and
	      the number of available physical pages.

       mongod --noscripting

	      Disables the scripting engine.

       mongod --notablescan

	      Forbids operations that require a	collection scan. See notables-
	      can for additional information.

       mongod --shutdown

	      The --shutdown option cleanly and	safely terminates  the	mongod
	      process.	When invoking mongod with this option you must set the
	      --dbpath option either directly or by way	of  the	 configuration
	      file and the --config option.

	      The --shutdown option is available only on Linux systems.

	      For   additional	ways  to  shut	down,  see  also  Stop	mongod
	      Processes.

       mongod --redactClientLogData

	      Available	in MongoDB Enterprise only.

	      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 oper-
	      ation codes, line	numbers, and source file names are still visi-
	      ble in the logs.

	      Use --redactClientLogData	in conjunction with Encryption at Rest
	      and TLS/SSL (Transport Encryption)  to  assist  compliance  with
	      regulatory requirements.

	      For example, a MongoDB deployment	might store Personally Identi-
	      fiable  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.

	      Diagnostics  on  a mongod	running	with --redactClientLogData may
	      be more difficult	due to the lack	 of  data  related  to	a  log
	      event. See the process logging manual page for an	example	of the
	      effect of	--redactClientLogData on log output.

	      On  a running mongod, use	setParameter with the redactClientLog-
	      Data parameter to	configure this setting.

       mongod --networkMessageCompressors

	      Default: snappy,zstd,zlib

	      Specifies	the default compressor(s) to use for communication be-
	      tween this mongod	instance and:

		      other members of	the deployment if the instance is part
		       of a replica set	or a sharded cluster

		      mongosh

		      drivers that support the	OP_COMPRESSED message format.

	      MongoDB supports the following compressors:

		      snappy

		      zlib

		      zstd

	      Both mongod and mongos  instances	 default  to  snappy,zstd,zlib
	      compressors, in that order.

	      To disable network compression, set the value to disabled.

	      Messages	are  compressed	 when both parties enable network com-
	      pression.	Otherwise, messages between  the  parties  are	uncom-
	      pressed.

	      If you specify multiple compressors, then	the order in which you
	      list the compressors matter as well as the communication initia-
	      tor.  For	 example,  if  mongosh specifies the following network
	      compressors zlib,snappy and the  mongod  specifies  snappy,zlib,
	      messages between mongosh and mongod uses zlib.

	      If the parties do	not share at least one common compressor, mes-
	      sages between the	parties	are uncompressed. For example, if mon-
	      gosh  specifies the network compressor zlib and mongod specifies
	      snappy, messages between mongosh and mongod are not compressed.

       mongod --timeZoneInfo

	      The full path from which to load the time	zone database. If this
	      option is	not provided, then MongoDB uses	its built-in time zone
	      database.

	      The configuration	file included with Linux  and  macOS  packages
	      sets  the	 time zone database path to /usr/share/zoneinfo	by de-
	      fault.

	      The built-in time	zone database is a copy	of the Olson/IANA time
	      zone database (https://www.iana.org/time-zones). It  is  updated
	      along  with MongoDB releases, but	the time zone database release
	      cycle differs from the MongoDB release cycle.  The  most	recent
	      release  of  the time zone database is available on our download
	      site  (https://downloads.mongodb.org/olson_tz_db/timezonedb-lat-
	      est.zip).

		wget https://downloads.mongodb.org/olson_tz_db/timezonedb-latest.zip
		unzip timezonedb-latest.zip
		mongod --timeZoneInfo timezonedb-2017b/

	      MongoDB  uses  the  third	party timelib (https://github.com/der-
	      ickr/timelib) library to provide	accurate  conversions  between
	      timezones.  Due to a recent update, timelib could	create inaccu-
	      rate time	zone conversions in older versions of MongoDB.

	      To explicitly link to the	time zone database in versions of Mon-
	      goDB  prior  to	5.0,   download	  the	time   zone   database
	      (https://downloads.mongodb.org/olson_tz_db/timezonedb-lat-
	      est.zip).	 and use the timeZoneInfo parameter.

	      processManagement.timeZoneInfo.

       mongod --outputConfig

	      Outputs  the  mongod instance's configuration options, formatted
	      in YAML, to stdout and exits the mongod instance.	For configura-
	      tion options that	uses  Externally  Sourced  Configuration  File
	      Values,  --outputConfig returns the resolved value for those op-
	      tions.

	      This may include any configured passwords	or secrets  previously
	      obfuscated through the external source.

	      For usage	examples, see:

		      Output  the  Configuration File with Resolved Expansion
		       Directive Values

		      Convert Command-Line Options to YAML

   LDAP	AUTHENTICATION OR AUTHORIZATION	OPTIONS
       mongod --ldapServers

	      Available	in MongoDB Enterprise only.

	      The LDAP server against which the	mongod authenticates users  or
	      determines  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 infrastructure partitions the LDAP  directory  over
	      multiple	LDAP  servers,	specify	 one LDAP server or any	of its
	      replicated instances to --ldapServers. MongoDB supports  follow-
	      ing   LDAP   referrals   as   defined   in   RFC	 4511	4.1.10
	      (https://www.rfc-editor.org/rfc/rfc4511.txt).   Do    not	   use
	      --ldapServers  for listing every LDAP server in your infrastruc-
	      ture.

	      This setting can be configured on	a running mongod using	setPa-
	      rameter.

	      If  unset,  mongod  cannot use LDAP authentication or authoriza-
	      tion.

       mongod --ldapValidateLDAPServerConfig

	      Available	in MongoDB Enterprise

	      A	flag that determines if	the mongod instance checks the	avail-
	      ability of the LDAP server(s) as part of its startup:

		      If  true, the mongod instance performs the availability
		       check and only continues	to start up if the LDAP	server
		       is available.

		      If false, the mongod instance  skips  the  availability
		       check;  i.e.  the  instance  starts up even if the LDAP
		       server is unavailable.

       mongod --ldapQueryUser

	      Available	in MongoDB Enterprise only.

	      The identity with	which mongod binds as, when connecting	to  or
	      performing queries on an LDAP server.

	      Only required if any of the following are	true:

		      Using LDAP authorization.

		      Using an	LDAP query for username	transformation.

		      The LDAP	server disallows anonymous binds

	      You must use --ldapQueryUser with	--ldapQueryPassword.

	      If unset,	mongod doesn't attempt to bind to the LDAP server.

	      This  setting can	be configured on a running mongod using	setPa-
	      rameter.

	      Windows MongoDB deployments can use --ldapBindWithOSDefaults in-
	      stead of --ldapQueryUser	and  --ldapQueryPassword.  You	cannot
	      specify both --ldapQueryUser and --ldapBindWithOSDefaults	at the
	      same time.

       Available in MongoDB Enterprise only.

       The password used to bind to an LDAP server when	using --ldapQueryUser.
       You must	use --ldapQueryPassword	with --ldapQueryUser.

       If not set, mongod does not attempt to bind to the LDAP server.

       You can configure this setting on a running mongod using	setParameter.

       The  ldapQueryPassword  setParameter command accepts either a string or
       an array	of strings. If ldapQueryPassword is set	to an  array,  MongoDB
       tries  each  password in	order until one	succeeds. Use a	password array
       to roll over the	LDAP account password without downtime.

       Windows MongoDB deployments can use --ldapBindWithOSDefaults instead of
       --ldapQueryUser	and  --ldapQueryPassword.   You	 cannot	 specify  both
       --ldapQueryPassword and --ldapBindWithOSDefaults	at the same time.

       mongod --ldapBindWithOSDefaults

	      Default: false

	      Available	in MongoDB Enterprise for the Windows platform only.

	      Allows mongod to authenticate, or	bind, using your Windows login
	      credentials when connecting to the LDAP server.

	      Only required if:

		      Using LDAP authorization.

		      Using an	LDAP query for username	transformation.

		      The LDAP	server disallows anonymous binds

	      Use  --ldapBindWithOSDefaults  to	 replace  --ldapQueryUser  and
	      --ldapQueryPassword.

       mongod --ldapBindMethod

	      Default: simple

	      Available	in MongoDB Enterprise only.

	      The method mongod	uses to	authenticate to	an LDAP	 server.   Use
	      with  --ldapQueryUser  and --ldapQueryPassword to	connect	to the
	      LDAP server.

	      --ldapBindMethod supports	the following values:

		      simple -	mongod uses simple authentication.

		      sasl - mongod uses SASL protocol	for authentication

	      If you specify sasl, you can configure the available SASL	mecha-
	      nisms using --ldapBindSaslMechanisms. mongod defaults  to	 using
	      DIGEST-MD5 mechanism.

       mongod --ldapBindSaslMechanisms

	      Default: DIGEST-MD5

	      Available	in MongoDB Enterprise only.

	      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 dynami-
	      cally 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  li-
	      braries  by  default. Defer to the documentation associated with
	      each SASL	mechanism for guidance on installation and  configura-
	      tion.

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

	      Linux

			     The  KRB5_CLIENT_KTNAME environment variable re-
			      solves to	the name of the	 client	 Linux	Keytab
			      Files for	the host machine. For more on Kerberos
			      environment  variables, please defer to the Ker-
			      beros  documentation   (https://web.mit.edu/ker-
			      beros/krb5-1.13/doc/admin/env_variables.html).

			     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		     (https://msdn.mi-
		     crosoft.com/en-us/library/windows/desk-
		     top/aa380510(v=vs.85).aspx) 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.

	      Set --ldapBindMethod to sasl to use this option.

	      For  a  complete	list  of  SASL mechanisms see the IANA listing
	      (http://www.iana.org/assignments/sasl-mechanisms/sasl-mecha-
	      nisms.xhtml).  Defer to the documentation	for your LDAP  or  Ac-
	      tive  Directory service for identifying the SASL mechanisms com-
	      patible with the service.

	      MongoDB is not a source of SASL mechanism	libraries, nor is  the
	      MongoDB documentation a definitive source	for installing or con-
	      figuring	any  given  SASL mechanism. For	documentation and sup-
	      port, defer to the SASL mechanism	library	vendor or owner.

	      For more information on SASL, defer to the following resources:

		      For Linux, please  see  the  Cyrus  SASL	 documentation
		       (https://www.cyrusimap.org/sasl/).

		      For  Windows, please see	the Windows SASL documentation
		       (https://msdn.microsoft.com/en-us/li-
		       brary/cc223500.aspx).

       mongod --ldapTransportSecurity

	      Default: tls

	      Available	in MongoDB Enterprise only.

	      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	Enter-
	      prise installation, via the libldap dependency. See the documen-
	      tation  for  TLS Options in the ldap.conf	OpenLDAP documentation
	      (http://www.openldap.org/software/man.cgi?query=ldap.conf&man-
	      path=OpenLDAP+2.4-Release) for more complete instructions.

	      For Windows deployment, you must add the LDAP server CA certifi-
	      cates 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.

	      Set  --ldapTransportSecurity  to none to disable TLS/SSL between
	      mongod and the LDAP server.

	      Setting --ldapTransportSecurity to none transmits	plaintext  in-
	      formation	 and  possibly credentials between mongod and the LDAP
	      server.

       mongod --ldapTimeoutMS

	      Default: 10000

	      Available	in MongoDB Enterprise only.

	      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	setPa-
	      rameter.

       mongod --ldapRetryCount

	      Default: 0

	      Available	in MongoDB Enterprise only.

	      Number of	operation retries by the server	LDAP manager  after  a
	      network error.

       mongod --ldapUserToDNMapping

	      Available	in MongoDB Enterprise only.

	      Maps  the	 username  provided  to	mongod for authentication to a
	      LDAP Distinguished Name (DN). You	may need to use	--ldapUserToD-
	      NMapping to transform a username into an LDAP DN in the  follow-
	      ing scenarios:

		      Performing  LDAP	 authentication	with simple LDAP bind-
		       ing, where users	authenticate to	MongoDB	with usernames
		       that are	not full LDAP DNs.

		      Using an	LDAP authorization  query  template  that  re-
		       quires a	DN.

		      Transforming the	usernames of clients authenticating to
		       Mongo  DB  using	 different  authentication mechanisms,
		       such as x.509 or	kerberos, to a full LDAP DN for	autho-
		       rization.

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

	      Each document in the array has the following form:

		{
		  match: "<regex>"
		  substitution:	"<LDAP DN>" | ldapQuery: "<LDAP	Query>"
		}

		     

		          Field

		          Description

		          Example

		     

		          match

		          An  ECMAScript-formatted regular expression (regex)
			   to match against a provided username.  Each	paren-
			   thesis-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 (http://www.regu-
			   lar-expressions.info/refcapture.html)     extracted
			   from	the  authentication  username  via  the	 match
			   regex.

			   The	result	of the substitution must be an RFC4514
			   (https://www.ietf.org/rfc/rfc4514.txt)      escaped
			   string.

		          "cn={0},ou=engineering, dc=example,dc=com"

		     

		          ldapQuery

		          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  (http://www.regular-expressions.info/refcap-
			   ture.html) extracted	from the authentication	 user-
			   name	via the	match expression.  mongod executes the
			   query  against the LDAP server to retrieve the LDAP
			   DN for the authenticated user. mongod requires  ex-
			   actly one returned result for the transformation to
			   be successful, or mongod skips this transformation.

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

	      An	      explanation	       of	       RFC4514
	      (https://www.ietf.org/rfc/rfc4514.txt),		       RFC4515
	      (https://tools.ietf.org/html/rfc4515),		       RFC4516
	      (https://tools.ietf.org/html/rfc4516), or	LDAP queries is	out of
	      scope for	the MongoDB Documentation. Please review the  RFC  di-
	      rectly 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, mongod continues through the list of documents to find ad-
	      ditional matches.	If no matches are found	in  any	 document,  or
	      the  transformation the document describes fails,	mongod returns
	      an error.

	      mongod also returns an error if one of the transformations  can-
	      not be evaluated due to networking or authentication failures to
	      the LDAP server.	mongod rejects the connection request and does
	      not check	the remaining documents	in the array.

	      Starting	in MongoDB 5.0,	--ldapUserToDNMapping accepts an empty
	      string ""	or empty array [ ] in place of a mapping documnent. If
	      providing	an empty string	or empty array	to  --ldapUserToDNMap-
	      ping, MongoDB maps the authenticated username as the LDAP	DN. In
	      earlier  versions,  providing  an	 empty mapping document	causes
	      mapping to fail.

	      The following shows two transformation documents.	The first doc-
	      ument 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, plac-
	      ing anything preceeding the suffix into a	regex capture group.

		"[
		   {
		      match: "(.+)@ENGINEERING.EXAMPLE.COM",
		      substitution: "cn={0},ou=engineering,dc=example,dc=com"
		   },
		   {
		      match: "(.+)@DBA.EXAMPLE.COM",
		      ldapQuery: "ou=dba,dc=example,dc=com??one?(user={0})"

		   }

		]"

	      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=engi-
	      neering,dc=example,dc=com".

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

	      If --ldapUserToDNMapping is unset, mongod	applies	no transforma-
	      tions to the username when attempting to authenticate or	autho-
	      rize a user against the LDAP server.

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

       mongod --ldapAuthzQueryTemplate

	      Available	in MongoDB Enterprise only.

	      A	relative  LDAP	query  URL  formatted  conforming  to  RFC4515
	      (https://tools.ietf.org/html/rfc4515)	    and	       RFC4516
	      (https://tools.ietf.org/html/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.

	      In the URL, you can use the following substituion	tokens:

		     

		          Substitution	Token

		          Description

		     

		          {USER}

		          Substitutes	the  authenticated  username,  or  the
			   transformed username	if a username mapping is spec-
			   ified.

		     

		          {PROVIDED_USER}

		          Substitutes the supplied username, i.e. before  ei-
			   ther	authentication or LDAP transformation.

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

		[ dn  [	? [attributes] [ ? [scope] [ ? [filter]	[ ? [Extensions] ] ] ] ] ]

	      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  au-
	      thorized	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.

	      This LDAP	query returns any groups listed	in the LDAP  user  ob-
	      ject's memberOf attribute.

		"{USER}?memberOf?base"

	      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 member-
	      ship 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.

	      An explanation of	RFC4515	(https://tools.ietf.org/html/rfc4515),
	      RFC4516 (https://tools.ietf.org/html/rfc4516) or LDAP queries is
	      out of scope for the MongoDB Documentation.  Please  review  the
	      RFC directly or use your preferred LDAP resource.

   STORAGE OPTIONS
       mongod --storageEngine

	      Default: wiredTiger

	      Specifies	 the storage engine for	the mongod database. Available
	      values include:

		     

		          Value

		          Description

		     

		          wiredTiger

		          To specify the WiredTiger Storage Engine.

		     

		          inMemory

		          To specify the In-Memory Storage Engine.

			   Available in	MongoDB	Enterprise only.

	      If you attempt to	start a	mongod with a --dbpath	that  contains
	      data files produced by a storage engine other than the one spec-
	      ified by --storageEngine,	mongod doesn't start.

       mongod --dbpath

	      Default: /data/db	on Linux and macOS, atab on Windows

	      The directory where the mongod instance stores its data.

	      If  using	the default Configuration File included	with a package
	      manager installation of MongoDB, the  corresponding  storage.db-
	      Path setting uses	a different default.

	      The  files  in  --dbpath	must  correspond to the	storage	engine
	      specified	in --storageEngine. If the data	files  do  not	corre-
	      spond to --storageEngine,	mongod doesn't start.

       mongod --directoryperdb

	      Uses  a  separate	directory to store data	for each database. The
	      directories are under the	--dbpath directory, and	each subdirec-
	      tory name	corresponds to the database name.

	      Not available for	mongod instances that use the in-memory	 stor-
	      age engine.

	      Starting	in  MongoDB  5.0,  dropping  the final collection in a
	      database (or dropping the	database itself) when --directoryperdb
	      is enabled deletes the newly empty subdirectory for  that	 data-
	      base.

	      To change	the --directoryperdb option for	existing deployments:

		      For standalone instances:

		          Use	mongodump  on  the existing mongod instance to
			   generate a backup.

		          Stop	the mongod instance.

		          Add the --directoryperdb value and configure	a  new
			   data	directory

		          Restart the mongod instance.

		          Use	mongorestore  to  populate the new data	direc-
			   tory.

		      For replica sets:

		          Stop	a secondary member.

		          Add the --directoryperdb value and configure	a  new
			   data	directory to that secondary member.

		          Restart that	secondary.

		          Use	initial	 sync  to populate the new data	direc-
			   tory.

		          Update remaining secondaries	in the same fashion.

		          Step	down the primary, and update the  stepped-down
			   member in the same fashion.

       mongod --syncdelay

	      Default: 60

	      Controls	how  much time can pass	before MongoDB flushes data to
	      the data files.

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

	      The  mongod  process writes data very quickly to the journal and
	      lazily to	the data files.	--syncdelay has	no effect on  journal-
	      ing,  but	if --syncdelay is set to 0 the journal eventually con-
	      sumes all	available disk space.

	      Not available for	mongod instances that use the in-memory	 stor-
	      age engine.

	      To  provide  durable data, WiredTiger uses checkpoints. For more
	      details, see Journaling and the WiredTiger Storage Engine.

       mongod --upgrade

	      Upgrades the on-disk data	format of the files specified  by  the
	      --dbpath to the latest version, if needed.

	      This option only affects the operation of	the mongod if the data
	      files are	in an old format.

	      In most cases you	should not set this value, so you can exercise
	      the  most	control	over your upgrade process. See the MongoDB re-
	      lease notes for more information about the upgrade process.

       mongod --repair

	      Runs a repair routine on all databases for a mongod instance.

	      Starting in MongoDB 5.0:

		      The repair operation validates the collections to  find
		       any  inconsistencies  and fixes them if possible, which
		       avoids rebuilding the indexes.

		      If a collection's data file is salvaged or if the  col-
		       lection	has  inconsistencies that the validate step is
		       unable to fix, then all indexes are rebuilt.

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

		      Only use	mongod --repair	if you have no other  options.
		       The  operation  removes	and  does not save any corrupt
		       data during the repair process.

		      Avoid running --repair against a	replica	set member:

		          To repair a replica set member, if you have an  in-
			   tact	 copy  of  your	 data available	(e.g. a	recent
			   backup or an	intact member of the replica set), re-
			   store from that intact copy instead.	To learn more,
			   see Resync a	Member of a Replica Set.

		          If you 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.

		      Before using --repair, make a backup copy of the	dbpath
		       directory.

		      If  repair  fails  to complete for any reason, you must
		       restart the instance using the --repair option.

       mongod --journalCommitInterval

	      Default: 100

	      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.

	      On WiredTiger, the default journal commit	interval is  100  mil-
	      liseconds. A write that includes or implies j:true causes	an im-
	      mediate  sync  of	the journal. For details and additional	condi-
	      tions that affect	the frequency  of  the	sync,  see  Journaling
	      Process.

	      Not  available for mongod	instances that use the in-memory stor-
	      age engine.

   WIREDTIGER OPTIONS
       mongod --wiredTigerCacheSizeGB

	      Defines the maximum size of the internal cache  that  WiredTiger
	      uses  for	 all  data. The	memory consumed	by an index build (see
	      maxIndexBuildMemoryUsageMegabytes)   is	separate   from	   the
	      WiredTiger cache memory.

	      Values can range from 0.25 GB to 10000 GB.

	      The  default WiredTiger internal cache size is the larger	of ei-
	      ther:

		      50% of (RAM - 1 GB), or

		      256 MB.

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

	      In some instances, such as when  running	in  a  container,  the
	      database can have	memory constraints that	are lower than the to-
	      tal  system memory. In such instances, this memory limit,	rather
	      than the total system memory, is used as the maximum RAM	avail-
	      able.

	      To see the memory	limit, see hostInfo.system.memLimitMB.

	      Avoid  increasing	 the  WiredTiger internal cache	size above its
	      default value.

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

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

	      The  --wiredTigerCacheSizeGB  limits  the	size of	the WiredTiger
	      internal cache. The operating system  uses  the  available  free
	      memory for filesystem cache, which allows	the compressed MongoDB
	      data  files to stay in memory. In	addition, the operating	system
	      uses 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 ma-
	      chine contains multiple MongoDB instances, then you  should  de-
	      crease the setting to accommodate	the other mongod instances.

	      If  you  run  mongod  in a container (for	example, lxc, cgroups,
	      Docker, etc.) that does not have access to all of	the RAM	avail-
	      able 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. See memLimitMB.

       mongod --wiredTigerJournalCompressor

	      Default: snappy

	      Specifies	 the type of compression to use	to compress WiredTiger
	      journal data.

	      Available	compressors are:

		      none

		      snappy

		      zlib

		      zstd

       mongod --wiredTigerDirectoryForIndexes

	      When you start mongod with --wiredTigerDirectoryForIndexes, mon-
	      god 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 collec-
	      tion 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 run-
	      ning, move the index subdirectory	to the destination and	create
	      a	 symbolic link named index under the data directory to the new
	      destination.

       mongod --wiredTigerCollectionBlockCompressor

	      Default: snappy

	      Specifies	the default compression	for collection data.  You  can
	      override	this  on  a per-collection basis when creating collec-
	      tions.

	      Available	compressors are:

		      none

		      snappy

		      zlib

		      zstd

	      --wiredTigerCollectionBlockCompressor  affects  all  collections
	      created. If you change the value of --wiredTigerCollectionBlock-
	      Compressor  on  an  existing MongoDB deployment, all new collec-
	      tions use	the specified compressor.  Existing  collections  con-
	      tinue to use the compressor specified when they were created, or
	      the default compressor at	that time.

       mongod --wiredTigerIndexPrefixCompression

	      Default: true

	      Enables or disables prefix compression for index data.

	      Specify  true  for  --wiredTigerIndexPrefixCompression to	enable
	      prefix compression for index data, or false  to  disable	prefix
	      compression for index data.

	      The  --wiredTigerIndexPrefixCompression  setting affects all in-
	      dexes created. If	you change the value of	 --wiredTigerIndexPre-
	      fixCompression  on  an  existing MongoDB deployment, all new in-
	      dexes use	prefix compression. Existing indexes are not affected.

   REPLICATION OPTIONS
       mongod --replSet

	      Configures replication. Specify a	replica	set name as  an	 argu-
	      ment  to	this  set.  All	hosts in the replica set must have the
	      same set name.

	      If your application connects to more than	one replica set,  each
	      set  must	 have  a distinct name.	Some drivers group replica set
	      connections by replica set name.

       mongod --oplogSize

	      The maximum size in megabytes for	the oplog. The oplogSize  set-
	      ting configures the uncompressed size of the oplog, not the size
	      on disk.

	      The  oplog  can  grow  past  its	configured size	limit to avoid
	      deleting the majority commit point.

	      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,	chang-
	      ing the --oplogSize option doesn't affect	the size of the	oplog.
	      To  change the minimum oplog retention period after starting the
	      mongod, use replSetResizeOplog. replSetResizeOplog  enables  you
	      to  resize  the  oplog dynamically without restarting the	mongod
	      process. To persist the changes  made  using  replSetResizeOplog
	      through a	restart, update	the value of --oplogSize.

	      See Oplog	Size for more information.

       mongod --oplogMinRetentionHours

	      Specifies	 the  minimum number of	hours to preserve an oplog en-
	      try, where the decimal values  represent	the  fractions	of  an
	      hour. For	example, a value of 1.5	represents one hour and	thirty
	      minutes.

	      The value	must be	greater	than or	equal to 0. A value of 0 indi-
	      cates  that  the	mongod should truncate the oplog starting with
	      the oldest entries to  maintain  the  configured	maximum	 oplog
	      size.

	      Defaults to 0.

	      A	 mongod	 started with --oplogMinRetentionHours only removes an
	      oplog entry if:

		      The oplog has reached the maximum configured oplog size
		       and

		      The oplog entry is older	than the configured number  of
		       hours based on the host system clock.

	      The  mongod  has	the  following behavior	when configured	with a
	      minimum oplog retention period:

		      The oplog can grow without constraint so	as  to	retain
		       oplog  entries for the configured number	of hours. This
		       may result in reduction or exhaustion  of  system  disk
		       space  due  to  a  combination of high write volume and
		       large retention period.

		      If the oplog grows beyond its maximum size, the	mongod
		       may  continue to	hold that disk space even if the oplog
		       returns to its maximum size  or	is  configured	for  a
		       smaller	maximum	size. See Reducing Oplog Size Does Not
		       Immediately Return Disk Space.

		      The mongod compares the system wall clock to  an	 oplog
		       entries	creation  wall clock time when enforcing oplog
		       entry retention.	Clock drift between cluster components
		       may result in unexpected	oplog retention	behavior.  See
		       Clock  Synchronization  for  more  information on clock
		       synchronization across cluster members.

	      To change	the minimum oplog retention period after starting  the
	      mongod,  use replSetResizeOplog.	replSetResizeOplog enables you
	      to resize	the oplog dynamically without  restarting  the	mongod
	      process.	To  persist  the changes made using replSetResizeOplog
	      through a	restart, update	the value of --oplogMinRetentionHours.

       mongod --enableMajorityReadConcern

	      Default: true

	      Configures support for "majority"	read concern.

	      Starting in MongoDB 5.0, --enableMajorityReadConcern  cannot  be
	      changed  and  is always set to true. In earlier versions of Mon-
	      goDB, --enableMajorityReadConcern	was configurable.

	      If you are using a three-member primary-secondary-arbiter	 (PSA)
	      architecture, consider the following:

		      The  write concern "majority" can cause performance is-
		       sues if a secondary is unavailable or lagging. For  ad-
		       vice on how to mitigate these issues, see Mitigate Per-
		       formance	Issues with PSA	Replica	Set.

		      If  you	are  using a global default "majority" and the
		       write concern is	less than the size  of	the  majority,
		       your  queries  may  return stale	(not fully replicated)
		       data.

   SHARDED CLUSTER OPTIONS
       mongod --configsvr

	      Required if starting a config server.

	      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	 data-
	      base  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.

	      When  starting  a	MongoDB	server with --configsvr, you must also
	      specify a	--replSet.

	      The use of the deprecated	mirrored mongod	 instances  as	config
	      servers (SCCC) is	no longer supported.

	      The  replica  set	 config	servers	(CSRS) must run	the WiredTiger
	      storage engine.

	      The --configsvr option creates a local oplog.

	      Do not  use  the	--configsvr  option  with  --shardsvr.	Config
	      servers cannot be	a shard	server.

	      Do  not  use  the	 --configsvr  with  the	skipShardingConfigura-
	      tionChecks parameter. That is, if	you are	 temporarily  starting
	      the  mongod  as a	standalone for maintenance operations, include
	      the parameter skipShardingConfigurationChecks and	exclude	--con-
	      figsvr.  Once maintenance	has completed, remove  the  skipShard-
	      ingConfigurationChecks parameter and restart with	--configsvr.

       mongod --shardsvr

	      Required if starting a shard server.

	      Configures this mongod instance as a shard in a sharded cluster.
	      The default port for these instances is 27018.

	      When  starting  a	 MongoDB server	with --shardsvr, you must also
	      specify a	--replSet.

	      Do  not  use  the	 --shardsvr  with  the	skipShardingConfigura-
	      tionChecks  parameter.  That is, if you are temporarily starting
	      the mongod as a standalone for maintenance  operations,  include
	      the   parameter	skipShardingConfigurationChecks	  and  exclude
	      --shardsvr.  Once	maintenance has	completed,  remove  the	 skip-
	      ShardingConfigurationChecks    parameter	  and	restart	  with
	      --shardsvr.

   TLS OPTIONS
       Configure mongod	and mongos for TLS/SSL for full	documentation of  Mon-
       goDB's support.

       mongod --tlsMode

	      Enables  TLS  used  for all network connections. The argument to
	      the --tlsMode option can be one of the following:

		     

		          Value

		          Description

		     

		          disabled

		          The server does not use TLS.

		     

		          allowTLS

		          Connections between servers do not use TLS. For in-
			   coming connections, the server accepts both TLS and
			   non-TLS.

		     

		          preferTLS

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

		     

		          requireTLS

		          The server uses and accepts only TLS	encrypted con-
			   nections.

	      If --tlsCAFile or	tls.CAFile is not specified and	 you  are  not
	      using  x.509 authentication, you must set	the tlsUseSystemCA pa-
	      rameter to true. This makes MongoDB use the system-wide CA  cer-
	      tificate store when connecting to	a TLS-enabled server.

	      If using x.509 authentication, --tlsCAFile or tls.CAFile must be
	      specified	unless using --tlsCertificateSelector.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsCertificateKeyFile

	      Specifies	 the  .pem file	that contains both the TLS certificate
	      and key.

	      On macOS or Windows, you can  use	 the  --tlsCertificateSelector
	      option  to specify a certificate from the	operating system's se-
	      cure certificate store instead of	a PEM key file.	 --tlsCertifi-
	      cateKeyFile  and	--tlsCertificateSelector  options are mutually
	      exclusive.  You can only specify one.

		      On Linux/BSD, you must specify  --tlsCertificateKeyFile
		       when TLS/SSL is enabled.

		      On  Windows or macOS, you must specify either --tlsCer-
		       tificateKeyFile	 or   --tlsCertificateSelector	  when
		       TLS/SSL is enabled.

		       For  Windows  only,  MongoDB does not support encrypted
		       PEM files. The mongod fails to start if	it  encounters
		       an  encrypted  PEM file.	To securely store and access a
		       certificate for use with	TLS on Windows,	use  --tlsCer-
		       tificateSelector.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsCertificateKeyFilePassword

	      Specifies	the password to	decrypt	the certificate-key file (i.e.
	      --tlsCertificateKeyFile).	 Use  the --tlsCertificateKeyFilePass-
	      word option only if the certificate-key file  is	encrypted.  In
	      all  cases, the mongod redacts the password from all logging and
	      reporting	output.

		      On Linux/BSD, if	the private key	in the PEM file	is en-
		       crypted and you do not specify the --tlsCertificateKey-
		       FilePassword option, MongoDB prompts for	a  passphrase.
		       See TLS/SSL Certificate Passphrase.

		      On  macOS,  if  the  private key	in the PEM file	is en-
		       crypted,	you must explicitly specify the	 --tlsCertifi-
		       cateKeyFilePassword  option. Alternatively, you can use
		       a  certificate  from  the  secure  system  store	  (see
		       --tlsCertificateSelector)  instead of a PEM file	or use
		       an unencrypted PEM file.

		      On Windows, MongoDB does	not support encrypted certifi-
		       cates.  The mongod fails	if it encounters an  encrypted
		       PEM file. Use --tlsCertificateSelector instead.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --clusterAuthMode

	      Default: keyFile

	      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 key-
			   files.

		     

		          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 cer-
			   tificate for	authentication	but  can  accept  both
			   keyfiles and	x.509 certificates.

		     

		          x509

		          Recommended.	Send the x.509 certificate for authen-
			   tication and	accept only x.509 certificates.

	      If  --tlsCAFile  or  tls.CAFile is not specified and you are not
	      using x.509 authentication, you must set the tlsUseSystemCA  pa-
	      rameter  to true.	This makes MongoDB use the system-wide CA cer-
	      tificate store when connecting to	a TLS-enabled server.

	      If using x.509 authentication, --tlsCAFile or tls.CAFile must be
	      specified	unless using --tlsCertificateSelector.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsClusterFile

	      Specifies	the .pem file that contains the	x.509  certificate-key
	      file  for	 membership  authentication for	the cluster or replica
	      set.

	      On macOS or Windows, you can use the  --tlsClusterCertificateSe-
	      lector  option  to specify a certificate from the	operating sys-
	      tem's secure certificate	store  instead	of  a  PEM  key	 file.
	      --tlsClusterFile and --tlsClusterCertificateSelector options are
	      mutually exclusive. You can only specify one.

	      If  --tlsClusterFile does	not specify the	.pem file for internal
	      cluster authentication or	the  alternative  --tlsClusterCertifi-
	      cateSelector,  the  cluster  uses	the .pem file specified	in the
	      --tlsCertificateKeyFile option or	the  certificate  returned  by
	      the --tlsCertificateSelector.

	      If using x.509 authentication, --tlsCAFile or tls.CAFile must be
	      specified	unless using --tlsCertificateSelector.

	      mongod  /	 mongos	 logs a	warning	on connection if the presented
	      x.509 certificate	expires	within 30 days	of  the	 mongod/mongos
	      host  system time. See x.509 Certificates	Nearing	Expiry Trigger
	      Warnings for more	information.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

	      For Windows only,	MongoDB	does not support encrypted PEM	files.
	      The  mongod  fails  to  start  if	it encounters an encrypted PEM
	      file. To securely	store and access a certificate	for  use  with
	      membership  authentication  on Windows, use --tlsClusterCertifi-
	      cateSelector.

       mongod --tlsCertificateSelector

	      Available	on Windows and macOS as	an  alternative	 to  --tlsCer-
	      tificateKeyFile.

	      Specifies	 a  certificate	property in order to select a matching
	      certificate from the operating system's certificate store	to use
	      for TLS.

	      The --tlsCertificateKeyFile and --tlsCertificateSelector options
	      are mutually exclusive.  You can only specify one.

	      --tlsCertificateSelector	accepts	 an  argument  of  the	format
	      <property>=<value>  where	the property can be one	of the follow-
	      ing:

		     

		          Property

		          Value type

		          Description

		     

		          subject

		          ASCII string

		          Subject name	or common name on certificate

		     

		          thumbprint

		          hex string

		          A sequence of bytes,	expressed as hexadecimal, used
			   to identify a public	key by its SHA-1 digest.

			   The thumbprint is sometimes referred	to as  a  fin-
			   gerprint.

	      When  using  the system SSL certificate store, OCSP (Online Cer-
	      tificate Status Protocol)	is used	 to  validate  the  revocation
	      status of	certificates.

	      The  mongod  searches  the operating system's secure certificate
	      store for	the CA certificates required to	validate the full cer-
	      tificate chain of	the specified TLS certificate.	 Specifically,
	      the  secure  certificate	store must contain the root CA and any
	      intermediate CA certificates required to build the full certifi-
	      cate chain to the	TLS certificate. Do  not  use  --tlsCAFile  or
	      --tlsClusterCAFile  to specify the root and intermediate CA cer-
	      tificate

	      For example, if the TLS/SSL certificate was signed with a	single
	      root CA certificate, the secure certificate store	 must  contain
	      that  root CA certificate. If the	TLS/SSL	certificate was	signed
	      with an intermediate  CA	certificate,  the  secure  certificate
	      store must contain the intermedia	CA certificate and the root CA
	      certificate.

	      You  cannot use the rotateCertificates command or	the db.rotate-
	      Certificates() shell method when using net.tls.certificateSelec-
	      tor or --tlsCertificateSelector set to thumbprint

       mongod --tlsClusterCertificateSelector

	      Available	on Windows and macOS as	an alternative	to  --tlsClus-
	      terFile.

	      Specifies	 a  certificate	property in order to select a matching
	      certificate from the operating system's  certificate  store  for
	      internal x.509 membership	authentication.

	      --tlsClusterFile and --tlsClusterCertificateSelector options are
	      mutually exclusive. You can only specify one.

	      --tlsClusterCertificateSelector  accepts an argument of the for-
	      mat <property>=<value> where the property	can be one of the fol-
	      lowing:

		     

		          Property

		          Value type

		          Description

		     

		          subject

		          ASCII string

		          Subject name	or common name on certificate

		     

		          thumbprint

		          hex string

		          A sequence of bytes,	expressed as hexadecimal, used
			   to identify a public	key by its SHA-1 digest.

			   The thumbprint is sometimes referred	to as  a  fin-
			   gerprint.

	      The  mongod  searches  the operating system's secure certificate
	      store for	the CA certificates required to	validate the full cer-
	      tificate chain of	the specified cluster  certificate.   Specifi-
	      cally, the secure	certificate store must contain the root	CA and
	      any intermediate CA certificates required	to build the full cer-
	      tificate	 chain	 to   the  cluster  certificate.  Do  not  use
	      --tlsCAFile or --tlsClusterCAFile	to specify the root and	inter-
	      mediate CA certificate.

	      For example, if the cluster certificate was signed with a	single
	      root CA certificate, the secure certificate store	 must  contain
	      that  root CA certificate. If the	cluster	certificate was	signed
	      with an intermediate  CA	certificate,  the  secure  certificate
	      store must contain the intermedia	CA certificate and the root CA
	      certificate.

	      mongod  /	 mongos	 logs a	warning	on connection if the presented
	      x.509 certificate	expires	within 30 days	of  the	 mongod/mongos
	      host  system time. See x.509 Certificates	Nearing	Expiry Trigger
	      Warnings for more	information.

       mongod --tlsClusterPassword

	      Specifies	the password to	decrypt	the x.509 certificate-key file
	      specified	with --tlsClusterFile.	Use  the  --tlsClusterPassword
	      option  only  if	the  certificate-key file is encrypted.	In all
	      cases, the mongod	redacts	the password from all logging and  re-
	      porting output.

		      On  Linux/BSD,  if the private key in the x.509 file is
		       encrypted and you do not	specify	the  --tlsClusterPass-
		       word  option,  MongoDB  prompts	for  a passphrase. See
		       TLS/SSL Certificate Passphrase.

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

		      On Windows, MongoDB does	not support encrypted certifi-
		       cates.	The mongod fails if it encounters an encrypted
		       PEM file. Use --tlsClusterCertificateSelector instead.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsCAFile

	      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.

	      When  starting  a	mongod instance	with TLS/SSL enabled, you must
	      specify a	value for the  --tlsCAFile  flag,  the	net.tls.CAFile
	      configuration option, or the tlsUseSystemCA parameter.

	      --tlsCAFile, tls.CAFile, and tlsUseSystemCA are all mutually ex-
	      clusive.

	      Windows/macOS Only

		     If	using --tlsCertificateSelector and/or --tlsClusterCer-
		     tificateSelector,	do  not	use --tlsCAFile	to specify the
		     root and intermediate CA certificates. Store all CA  cer-
		     tificates	required  to  validate the full	trust chain of
		     the --tlsCertificateSelector and/or  --tlsClusterCertifi-
		     cateSelector   certificates  in  the  secure  certificate
		     store.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsClusterCAFile

	      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.
	      --tlsClusterCAFile requires that --tlsCAFile is set.

	      If  --tlsClusterCAFile  does not specify the .pem	file for vali-
	      dating the certificate from a client establishing	a  connection,
	      the  cluster uses	the .pem file specified	in the --tlsCAFile op-
	      tion.

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

	      Windows/macOS Only

		     If	using --tlsCertificateSelector and/or --tlsClusterCer-
		     tificateSelector,	do not use --tlsClusterCAFile to spec-
		     ify the root and intermediate CA certificates. Store  all
		     CA	certificates required to validate the full trust chain
		     of	 the  --tlsCertificateSelector and/or --tlsClusterCer-
		     tificateSelector certificates in the  secure  certificate
		     store.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsCRLFile

	      Specifies	the .pem file that contains the	Certificate Revocation
	      List.  Specify  the file name of the .pem	file using relative or
	      absolute paths.

		      You cannot specify a CRL	file on	 macOS.	 Instead,  you
		       can  use	 the  system SSL certificate store, which uses
		       OCSP (Online Certificate	Status Protocol)  to  validate
		       the  revocation	status	of certificates. See --tlsCer-
		       tificateSelector	to  use	 the  system  SSL  certificate
		       store.

		      To  check  for  certificate revocation, MongoDB enables
		       the use of OCSP (Online Certificate Status Protocol) by
		       default as an alternative to specifying a CRL  file  or
		       using the system	SSL certificate	store.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsAllowInvalidCertificates

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

	      If  you  specify	--tlsAllowInvalidCertificates  or tls.allowIn-
	      validCertificates: true when using x.509 authentication, an  in-
	      valid  certificate is only sufficient to establish a TLS connec-
	      tion but is insufficient for authentication.

	      When using the  --tlsAllowInvalidCertificates  setting,  MongoDB
	      logs a warning regarding the use of the invalid certificate.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsAllowInvalidHostnames

	      Disables	the  validation	 of the	hostnames in TLS 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.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsAllowConnectionsWithoutCertificates

	      By  default,  the	 server	bypasses client	certificate validation
	      unless the server	is configured to use a CA file.	If a  CA  file
	      is provided, the following rules apply:

		      For  clients that don't provide certificates, mongod or
		       mongos encrypts the TLS/SSL  connection,	 assuming  the
		       connection is successfully made.

		      For clients that	present	a certificate, mongod performs
		       certificate validation using the	root certificate chain
		       specified  by  --tlsCAFile  and reject clients with in-
		       valid certificates.

	      Use the --tlsAllowConnectionsWithoutCertificates option  if  you
	      have  a  mixed  deployment  that includes	clients	that do	not or
	      cannot present certificates to the mongod.

	      For more information about TLS and MongoDB, see Configure	mongod
	      and mongos for TLS/SSL and TLS/SSL Configuration for Clients .

       mongod --tlsDisabledProtocols

	      Prevents a MongoDB server	running	with TLS from accepting	incom-
	      ing connections that use a specific protocol  or	protocols.  To
	      specify multiple protocols, use a	comma separated	list of	proto-
	      cols.

	      --tlsDisabledProtocols   recognizes   the	 following  protocols:
	      TLS1_0, TLS1_1, TLS1_2, and TLS1_3.

		      On macOS, you cannot  disable  TLS1_1  and  leave  both
		       TLS1_0  and  TLS1_2  enabled. You must disable at least
		       one of the other	two, for example, TLS1_0,TLS1_1.

		      To list multiple	protocols, specify as  a  comma	 sepa-
		       rated list of protocols.	For example TLS1_0,TLS1_1.

		      Specifying an unrecognized protocol prevents the	server
		       from starting.

		      The  specified disabled protocols overrides any default
		       disabled	protocols.

	      MongoDB disables the use of TLS 1.0 if TLS 1.1+ is available  on
	      the  system.  To	enable	the  disabled TLS 1.0, specify none to
	      --tlsDisabledProtocols.

	      Members of replica sets and sharded clusters must	speak at least
	      one protocol in common.

	      Disallow Protocols

       mongod --tlsFIPSMode

	      Directs the mongod to use	the FIPS mode  of  the	 TLS  library.
	      Your system must have a FIPS compliant library to	use the	--tls-
	      FIPSMode option.

	      FIPS-compatible  TLS/SSL is available only in MongoDB Enterprise
	      (http://www.mongodb.com/products/mongodb-enterprise-ad-
	      vanced?tck=docs_server). See Configure MongoDB for FIPS for more
	      information.

   PROFILER OPTIONS
       mongod --profile

	      Default: 0

	      Configures the database profiler level.  The following  profiler
	      levels are available:

		     

		          Level

		          Description

		     

		          0

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

		     

		          1

		          The profiler	collects data for operations that  ex-
			   ceed	the slowms threshold or	match a	specified fil-
			   ter.

			   When	a filter is set:

			   	 The  slowms  and  sampleRate  options are not
				 used for profiling.

			   	 The profiler only  captures  operations  that
				 match the filter.

		     

		          2

		          The profiler	collects data for all operations.

	      Profiling	 can  degrade performance and expose unencrypted query
	      data in the system log. Carefully	consider any  performance  and
	      security	implications  before configuring and enabling the pro-
	      filer on a production deployment.

	      See Profiler Overhead for	more information on potential  perfor-
	      mance degradation.

       mongod --slowms

	      Default: 100

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

	      Slow operations are logged based on workingMillis, which is  the
	      amount  of  time	that MongoDB spends working on that operation.
	      This means that factors such as waiting for locks	and flow  con-
	      trol  do not affect whether an operation exceeds the slow	opera-
	      tion threshold.

	      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 diag-
	      nostic log regardless of their latency with the following	excep-
	      tion: the	logging	of slow	oplog entry  messages  by  the	secon-
	      daries.  The  secondaries	 log  only the slow oplog entries; in-
	      creasing the logLevel does not log all oplog entries.

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

	      Database Profiler

       mongod --slowOpSampleRate

	      Default: 1.0

	      The  fraction  of	 slow  operations  that	 should	be profiled or
	      logged.  --slowOpSampleRate accepts values between 0 and 1,  in-
	      clusive.

	      --slowOpSampleRate  does not affect the slow oplog entry logging
	      by the secondary members of a replica set. Secondary members log
	      all oplog	entries	that  take  longer  than  the  slow  operation
	      threshold	regardless of the --slowOpSampleRate.

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

   AUDIT OPTIONS
       mongod --auditCompressionMode

	      Specifies	the compression	mode for  audit	 log  encryption.  You
	      must  also  enable  audit	log encryption using either --auditEn-
	      cryptionKeyUID or	--auditLocalKeyFile.

	      --auditCompressionMode can be set	to one of these	values:

		     

		          Value

		          Description

		     

		          zstd

		          Use the zstd	algorithm to compress the audit	log.

		     

		          none	(default)

		          Do not compress the audit log.

	      Available	  only	 in   MongoDB	Enterprise    (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server).
	      MongoDB  Enterprise  and	Atlas have different configuration re-
	      quirements.

       mongod --auditDestination

	      Enables auditing and specifies  where  mongod  sends  all	 audit
	      events.

	      --auditDestination can have one of the following values:

		     

		          Value

		          Description

		     

		          syslog

		          Output  the	audit events to	syslog in JSON format.
			   Not available on Windows.  Audit  messages  have  a
			   syslog  severity level of info and a	facility level
			   of user.

			   The syslog message limit can	result in the  trunca-
			   tion	of audit messages. The auditing	system neither
			   detects  the	 truncation nor	errors upon its	occur-
			   rence.

		     

		          console

		          Output the audit events to stdout in	JSON format.

		     

		          file

		          Output the audit events to the  file	 specified  in
			   --auditPath	in the format specified	in --auditFor-
			   mat.

	      Available	  only	 in   MongoDB	Enterprise    (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server)
	      and MongoDB Atlas	(https://cloud.mongodb.com/user#/atlas/login).

       mongod --auditEncryptionKeyUID

	      Specifies	the unique identifier of the Key Management Interoper-
	      ability Protocol (KMIP) key for audit log	encryption.

	      You  cannot  use --auditEncryptionKeyUID and --auditLocalKeyFile
	      together.

	      Available	  only	 in   MongoDB	Enterprise    (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server).
	      MongoDB  Enterprise  and	Atlas have different configuration re-
	      quirements.

       mongod --auditFormat

	      Specifies	the format of the output file for auditing if --audit-
	      Destination is file. The --auditFormat option can	 have  one  of
	      the following values:

		     

		          Value

		          Description

		     

		          JSON

		          Output  the audit events in JSON format to the file
			   specified in	--auditPath.

		     

		          BSON

		          Output the audit events in BSON  binary  format  to
			   the file specified in --auditPath.

	      Printing	audit  events to a file	in JSON	format degrades	server
	      performance more than printing to	a file in BSON format.

	      Available	  only	 in   MongoDB	Enterprise    (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server)
	      and MongoDB Atlas	(https://cloud.mongodb.com/user#/atlas/login).

       mongod --auditLocalKeyFile

	      Specifies	 the path and file name	for a local audit key file for
	      audit log	encryption.

	      Only use --auditLocalKeyFile for testing because the key is  not
	      secured.	To  secure the key, use	--auditEncryptionKeyUID	and an
	      external Key Management Interoperability Protocol	(KMIP) server.

	      You cannot use --auditLocalKeyFile  and  --auditEncryptionKeyUID
	      together.

	      Available	   only	  in   MongoDB	 Enterprise   (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server).
	      MongoDB Enterprise and Atlas have	 different  configuration  re-
	      quirements.

       mongod --auditPath

	      Specifies	the output file	for auditing if	--auditDestination has
	      value  of	 file.	The  --auditPath option	can take either	a full
	      path name	or a relative path name.

	      Available	  only	 in   MongoDB	Enterprise    (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server)
	      and MongoDB Atlas	(https://cloud.mongodb.com/user#/atlas/login).

       mongod --auditFilter

	      Specifies	 the filter to limit the types of operations the audit
	      system records. The option takes a string	 representation	 of  a
	      query document of	the form:

		{ <field1>: <expression1>, ... }

	      The  <field>  can	 be  any field in the audit message, including
	      fields returned in the param document.  The  <expression>	 is  a
	      query condition expression.

	      To  specify an audit filter, enclose the filter document in sin-
	      gle quotes to pass the document as a string.

	      To specify the audit filter in a configuration  file,  you  must
	      use the YAML format of the configuration file.

	      Available	   only	  in   MongoDB	 Enterprise   (http://www.mon-
	      godb.com/products/mongodb-enterprise-advanced?tck=docs_server)
	      and MongoDB Atlas	(https://cloud.mongodb.com/user#/atlas/login).

       mongod --auditSchema

	      Default: mongo

	      Specifies	the format used	for audit logs.	You can	specify	one of
	      the following values for --auditSchema:

		     

		          Value

		          Description

		     

		          mongo

		          Logs	are written in a format	designed by MongoDB.

			   For example log messages, see  mongo	 Schema	 Audit
			   Messages.

		     

		          OCSF

		          Logs	are written in OCSF (Open Cybersecurity	Schema
			   Framework)  format.	This option provides logs in a
			   standardized	format compatible with log processors.

			   For example log messages,  see  OCSF	 Schema	 Audit
			   Messages.

   INMEMORY OPTIONS
       mongod --inMemorySizeGB

	      Default: 50% of physical RAM minus 1 GB.

	      Maximum  amount  of memory to allocate for the in-memory storage
	      engine data, including indexes, the oplog	(if the	mongod is part
	      of a replica set), sharded cluster metadata, etc.

	      Values can range from 256MB to 10TB and can be a float.

	      By default, the in-memory	storage	engine uses  50%  of  physical
	      RAM minus	1 GB.

	      Available	in MongoDB Enterprise only.

   ENCRYPTION KEY MANAGEMENT OPTIONS
       mongod --enableEncryption

	      Default: false

	      Enables  encryption  for the WiredTiger storage engine. This op-
	      tion must	be enabled in order to pass  in	 encryption  keys  and
	      configurations.

	      Available	in MongoDB Enterprise only.

       mongod --encryptionCipherMode

	      Default: AES256-CBC

	      The cipher mode to use for encryption at rest:

		     

		          Mode

		          Description

		     

		          AES256-CBC

		          256-bit  Advanced  Encryption  Standard  in	Cipher
			   Block Chaining Mode

		     

		          AES256-GCM

		          256-bit  Advanced  Encryption   Standard   in   Ga-
			   lois/Counter	Mode

			   Available only on Linux.

			   MongoDB  Enterprise	on  Windows no longer supports
			   AES256-GCM as a  block  cipher  for	encryption  at
			   rest. This usage is only supported on Linux.

	      Available	in MongoDB Enterprise only.

       mongod --encryptionKeyFile

	      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
	      throws an	error.

	      The keyfile can contain only a single key. The key is  either  a
	      16 or 32 character string.

	      Requires --enableEncryption.

	      Available	in MongoDB Enterprise only.

       mongod --kmipKeyIdentifier

	      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	 --en-
	      ableEncryption.

	      If  unspecified,	MongoDB	requests 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	 iden-
	      tifier  or  the  data  is	 already encrypted with	a key, MongoDB
	      throws an	error

	      Available	in MongoDB Enterprise only.

       mongod --kmipRotateMasterKey

	      Default: false

	      If true, rotate the master key and re-encrypt the	internal  key-
	      store.

	      Available	in MongoDB Enterprise only.

	      KMIP Master Key Rotation

       mongod --kmipServerName

	      Hostname	or  IP	address	 of the	KMIP server to connect to. Re-
	      quires --enableEncryption.

	      You can specify multiple KMIP servers as a comma-separated list,
	      for   example:	server1.example.com,server2.example.com.    On
	      startup,	the  mongod attempts to	establish a connection to each
	      server in	the order listed, and  selects	the  first  server  to
	      which  it	 can  successfully establish a connection. KMIP	server
	      selection	occurs only at startup.

	      When connecting to a 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  cer-
	      tificate	presented by the KMIP server.  If SAN is present, mon-
	      god does not match against the CN.  If  the  hostname  does  not
	      match the	SAN (or	CN), the mongod	fails to connect.

	      Starting in MongoDB 4.2, when performing comparison of SAN, Mon-
	      goDB supports comparison of DNS names or IP addresses. In	previ-
	      ous versions, MongoDB only supports comparisons of DNS names.

	      Available	in MongoDB Enterprise only.

       mongod --kmipPort

	      Default: 5696

	      Port  number  to	use  to	communicate with the KMIP server.  Re-
	      quires --kmipServerName. Requires	--enableEncryption.

	      If specifying multiple KMIP servers with	--kmipServerName,  the
	      mongod  uses the port specified with --kmipPort for all provided
	      KMIP servers.

	      Available	in MongoDB Enterprise only.

       mongod --kmipConnectRetries

	      Default: 0

	      How many times to	retry  the  initial  connection	 to  the  KMIP
	      server.  Use together with --kmipConnectTimeoutMS	to control how
	      long the mongod waits for	a response between each	retry.

	      Available	in MongoDB Enterprise only.

       mongod --kmipConnectTimeoutMS

	      Default: 5000

	      Timeout  in  milliseconds	 to  wait for a	response from the KMIP
	      server.  If the --kmipConnectRetries setting is  specified,  the
	      mongod waits for the specified interval between retries.

	      Value must be 1000 or greater.

	      Available	in MongoDB Enterprise only.

       mongod --kmipClientCertificateSelector

	      Available	 on  Windows  and  macOS  as an	alternative to --kmip-
	      ClientCertificateFile.

	      --kmipClientCertificateFile and  --kmipClientCertificateSelector
	      options are mutually exclusive. You can only specify one.

	      Specifies	 a  certificate	property in order to select a matching
	      certificate from the operating system's certificate store	to au-
	      thenticate MongoDB to the	KMIP server.

	      --kmipClientCertificateSelector accepts an argument of the  for-
	      mat <property>=<value> where the property	can be one of the fol-
	      lowing:

		     

		          Property

		          Value type

		          Description

		     

		          subject

		          ASCII string

		          Subject name	or common name on certificate

		     

		          thumbprint

		          hex string

		          A sequence of bytes,	expressed as hexadecimal, used
			   to identify a public	key by its SHA-1 digest.

			   The	thumbprint  is sometimes referred to as	a fin-
			   gerprint.

	      Available	in MongoDB Enterprise only.

       mongod --kmipClientCertificateFile

	      Path to the .pem file used to authenticate MongoDB to  the  KMIP
	      server.  The  specified  .pem file must contain both the TLS/SSL
	      certificate and key.

	      To use this option, you must also	specify	 the  --kmipServerName
	      option.

	      Enabling	encryption  using  a KMIP server on Windows fails when
	      using --kmipClientCertificateFile	and the	KMIP  server  enforces
	      TLS 1.2.

	      To enable	encryption at rest with	KMIP on	Windows, you must:

		      Import the client certificate into the Windows Certifi-
		       cate Store.

		      Use the --kmipClientCertificateSelector option.

	      On  macOS	or Windows, you	can use	a certificate from the operat-
	      ing system's secure store	instead	of a PEM key file. See --kmip-
	      ClientCertificateSelector.

	      Available	in MongoDB Enterprise only.

       mongod --kmipClientCertificatePassword

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

	      Available	in MongoDB Enterprise only.

       mongod --kmipServerCAFile

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

	      On macOS or Windows, you can use a certificate from the  operat-
	      ing system's secure store	instead	of a PEM key file. See --kmip-
	      ClientCertificateSelector.  When	using the secure store,	you do
	      not need to, but can, also specify the --kmipServerCAFile.

       mongod --kmipActivateKeys

	      Default: true

	      Activates	all newly created KMIP keys upon creation and then pe-
	      riodically checks	those keys are in an active state.

	      When --kmipActivateKeys is true and you have existing keys on  a
	      KMIP  server, the	key must be activated first or the mongod node
	      fails to start.

	      If the key being used by the mongod transitions into  a  non-ac-
	      tive  state,  the	mongod node shuts down unless kmipActivateKeys
	      is false.	To ensure you have an active key, rotate the KMIP mas-
	      ter key by using --kmipRotateMasterKey.

       mongod --kmipKeyStatePollingSeconds

	      Default: 900 seconds

	      Frequency	in seconds at which mongod polls the KMIP  server  for
	      active keys.

	      To disable disable polling, set the value	to -1.

       mongod --kmipUseLegacyProtocol

	      Default: false

	      When  true, mongod uses KMIP protocol version 1.0	or 1.1 instead
	      of the default version. The default  KMIP	 protocol  is  version
	      1.2.

	      To  use  audit  log encryption with KMIP version 1.0 or 1.1, you
	      must specify auditEncryptKeyWithKMIPGet at startup.

       mongod --eseDatabaseKeyRollover

	      Roll over	the encrypted storage engine database keys  configured
	      with AES256-GCM cipher.

	      When  mongod  instance is	started	with this option, the instance
	      rotates the keys and exits.

	      Available	in MongoDB Enterprise only.

								     mongod(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=mongod&sektion=1&manpath=FreeBSD+Ports+14.3.quarterly>

home | help