nova.conf - configuration options¶
For a complete list of all available configuration options for each OpenStack Compute service, run bin/nova-<servicename> --help.
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| api_rate_limit = False | (Boolean) Whether to use per-user rate limiting for the api. This option is only used by v2 api. Rate limiting is removed from v2.1 api. |
| enable_new_services = True | (Boolean) Services to be added to the available pool on create |
| enabled_apis = osapi_compute, metadata | (List) A list of APIs to enable by default |
| enabled_ssl_apis = | (List) A list of APIs with enabled SSL |
| instance_name_template = instance-%08x | (String) Template string to be used to generate instance names |
| multi_instance_display_name_template = %(name)s-%(count)d | (String) When creating multiple instances with a single request using the os-multiple-create API extension, this template will be used to build the display name for each instance. The benefit is that the instances end up with different hostnames. To restore legacy behavior of every instance having the same name, set this option to “%(name)s”. Valid keys for the template are: name, uuid, count. |
| non_inheritable_image_properties = cache_in_nova, bittorrent | (List) These are image properties which a snapshot should not inherit from an instance |
| null_kernel = nokernel | (String) Kernel image that indicates not to use a kernel, but to use a raw disk image instead |
| osapi_compute_ext_list = | (List) DEPRECATED: Specify list of extensions to load when using osapi_compute_extension option with nova.api.openstack.compute.legacy_v2.contrib.select_extensions This option will be removed in the near future. After that point you have to run all of the API. |
| osapi_compute_extension = ['nova.api.openstack.compute.legacy_v2.contrib.standard_extensions'] | (Multi-valued) DEPRECATED: osapi compute extension to load. This option will be removed in the near future. After that point you have to run all of the API. |
| osapi_compute_link_prefix = None | (String) Base URL that will be presented to users in links to the OpenStack Compute API |
| osapi_compute_listen = 0.0.0.0 | (String) The IP address on which the OpenStack API will listen. |
| osapi_compute_listen_port = 8774 | (Integer) The port on which the OpenStack API will listen. |
| osapi_compute_workers = None | (Integer) Number of workers for OpenStack API service. The default will be the number of CPUs available. |
| osapi_hide_server_address_states = building | (List) List of instance states that should hide network info |
| servicegroup_driver = db | (String) The driver for servicegroup service. |
| snapshot_name_template = snapshot-%s | (String) Template string to be used to generate snapshot names |
| use_forwarded_for = False | (Boolean) Treat X-Forwarded-For as the canonical remote address. Only enable this if you have a sanitizing proxy. |
| [oslo_middleware] | |
| max_request_body_size = 114688 | (Integer) The maximum body size for each request, in bytes. |
| [oslo_versionedobjects] | |
| fatal_exception_format_errors = False | (Boolean) Make exception message format errors fatal |
| [service_auth] | |
| admin_password = password | (String) The service admin password |
| admin_project_domain = admin | (String) The admin project domain name |
| admin_tenant_name = admin | (String) The service admin tenant name |
| admin_user = admin | (String) The service admin user name |
| admin_user_domain = admin | (String) The admin user domain name |
| auth_url = http://127.0.0.1:5000/v2.0 | (String) Authentication endpoint |
| auth_version = 2 | (String) The auth version used to authenticate |
| endpoint_type = public | (String) The endpoint_type to be used |
| region = RegionOne | (String) The deployment region |
| service_name = lbaas | (String) The name of the service |
| Configuration option = Default value | Description |
|---|---|
| [osapi_v21] | |
| enabled = True | (Boolean) DEPRECATED: Whether the V2.1 API is enabled or not. This option will be removed in the near future. |
| extensions_blacklist = | (List) DEPRECATED: A list of v2.1 API extensions to never load. Specify the extension aliases here. This option will be removed in the near future. After that point you have to run all of the API. |
| extensions_whitelist = | (List) DEPRECATED: If the list is not empty then a v2.1 API extension will only be loaded if it exists in this list. Specify the extension aliases here. This option will be removed in the near future. After that point you have to run all of the API. |
| project_id_regex = None | (String) DEPRECATED: The validation regex for project_ids used in urls. This defaults to [0-9a-f-]+ if not set, which matches normal uuids created by keystone. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| auth_strategy = keystone | (String) The strategy to use for auth: keystone or noauth2. noauth2 is designed for testing only, as it does no actual credential checking. noauth2 provides administrative credentials only if ‘admin’ is specified as the username. |
| Configuration option = Default value | Description |
|---|---|
| [keystone_authtoken] | |
| admin_password = None | (String) Service user password. |
| admin_tenant_name = admin | (String) Service tenant name. |
| admin_token = None | (String) This option is deprecated and may be removed in a future release. Single shared secret with the Keystone configuration used for bootstrapping a Keystone installation, or otherwise bypassing the normal authentication process. This option should not be used, use admin_user and admin_password instead. |
| admin_user = None | (String) Service username. |
| auth_admin_prefix = | (String) Prefix to prepend at the beginning of the path. Deprecated, use identity_uri. |
| auth_host = 127.0.0.1 | (String) Host providing the admin Identity API endpoint. Deprecated, use identity_uri. |
| auth_port = 35357 | (Integer) Port of the admin Identity API endpoint. Deprecated, use identity_uri. |
| auth_protocol = https | (String) Protocol of the admin Identity API endpoint. Deprecated, use identity_uri. |
| auth_section = None | (Unknown) Config Section from which to load plugin specific options |
| auth_type = None | (Unknown) Authentication type to load |
| auth_uri = None | (String) Complete public Identity API endpoint. |
| auth_version = None | (String) API version of the admin Identity API endpoint. |
| cache = None | (String) Env key for the swift cache. |
| cafile = None | (String) A PEM encoded Certificate Authority to use when verifying HTTPs connections. Defaults to system CAs. |
| certfile = None | (String) Required if identity server requires client certificate |
| check_revocations_for_cached = False | (Boolean) If true, the revocation list will be checked for cached tokens. This requires that PKI tokens are configured on the identity server. |
| delay_auth_decision = False | (Boolean) Do not handle authorization requests within the middleware, but delegate the authorization decision to downstream WSGI components. |
| enforce_token_bind = permissive | (String) Used to control the use and type of token binding. Can be set to: “disabled” to not check token binding. “permissive” (default) to validate binding information if the bind type is of a form known to the server and ignore it if not. “strict” like “permissive” but if the bind type is unknown the token will be rejected. “required” any form of token binding is needed to be allowed. Finally the name of a binding method that must be present in tokens. |
| hash_algorithms = md5 | (List) Hash algorithms to use for hashing PKI tokens. This may be a single algorithm or multiple. The algorithms are those supported by Python standard hashlib.new(). The hashes will be tried in the order given, so put the preferred one first for performance. The result of the first hash will be stored in the cache. This will typically be set to multiple values only while migrating from a less secure algorithm to a more secure one. Once all the old tokens are expired this option should be set to a single value for better performance. |
| http_connect_timeout = None | (Integer) Request timeout value for communicating with Identity API server. |
| http_request_max_retries = 3 | (Integer) How many times are we trying to reconnect when communicating with Identity API Server. |
| identity_uri = None | (String) Complete admin Identity API endpoint. This should specify the unversioned root endpoint e.g. https://localhost:35357/ |
| include_service_catalog = True | (Boolean) (Optional) Indicate whether to set the X-Service-Catalog header. If False, middleware will not ask for service catalog on token validation and will not set the X-Service-Catalog header. |
| insecure = False | (Boolean) Verify HTTPS connections. |
| keyfile = None | (String) Required if identity server requires client certificate |
| memcache_pool_conn_get_timeout = 10 | (Integer) (Optional) Number of seconds that an operation will wait to get a memcached client connection from the pool. |
| memcache_pool_dead_retry = 300 | (Integer) (Optional) Number of seconds memcached server is considered dead before it is tried again. |
| memcache_pool_maxsize = 10 | (Integer) (Optional) Maximum total number of open connections to every memcached server. |
| memcache_pool_socket_timeout = 3 | (Integer) (Optional) Socket timeout in seconds for communicating with a memcached server. |
| memcache_pool_unused_timeout = 60 | (Integer) (Optional) Number of seconds a connection to memcached is held unused in the pool before it is closed. |
| memcache_secret_key = None | (String) (Optional, mandatory if memcache_security_strategy is defined) This string is used for key derivation. |
| memcache_security_strategy = None | (String) (Optional) If defined, indicate whether token data should be authenticated or authenticated and encrypted. If MAC, token data is authenticated (with HMAC) in the cache. If ENCRYPT, token data is encrypted and authenticated in the cache. If the value is not one of these options or empty, auth_token will raise an exception on initialization. |
| memcache_use_advanced_pool = False | (Boolean) (Optional) Use the advanced (eventlet safe) memcached client pool. The advanced pool will only work under python 2.x. |
| region_name = None | (String) The region in which the identity server can be found. |
| revocation_cache_time = 10 | (Integer) Determines the frequency at which the list of revoked tokens is retrieved from the Identity service (in seconds). A high number of revocation events combined with a low cache duration may significantly reduce performance. |
| signing_dir = None | (String) Directory used to cache files related to PKI tokens. |
| token_cache_time = 300 | (Integer) In order to prevent excessive effort spent validating tokens, the middleware caches previously-seen tokens for a configurable duration (in seconds). Set to -1 to disable caching completely. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| default_availability_zone = nova | (String) Default compute node availability_zone |
| default_schedule_zone = None | (String) Availability zone to use when user doesn’t specify one |
| internal_service_availability_zone = internal | (String) The availability_zone to show internal services under |
| Configuration option = Default value | Description |
|---|---|
| [barbican] | |
| cafile = None | (String) PEM encoded Certificate Authority to use when verifying HTTPs connections. |
| catalog_info = key-manager:barbican:public | (String) Info to match when looking for barbican in the service catalog. Format is: separated values of the form: <service_type>:<service_name>:<endpoint_type> |
| certfile = None | (String) PEM encoded client certificate cert file |
| endpoint_template = None | (String) Override service catalog lookup with template for barbican endpoint e.g. http://localhost:9311/v1/%(project_id)s |
| insecure = False | (Boolean) Verify HTTPS connections. |
| keyfile = None | (String) PEM encoded client certificate key file |
| os_region_name = None | (String) Region name of this node |
| timeout = None | (Integer) Timeout value for http requests |
| [certificates] | |
| barbican_auth = barbican_acl_auth | (String) Name of the Barbican authentication method to use |
| cert_manager_type = barbican | (String) Certificate Manager plugin. Defaults to barbican. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| ca_file = cacert.pem | (String) Filename of root CA |
| ca_path = $state_path/CA | (String) Where we keep our root CA |
| cert = self.pem | (String) SSL certificate file |
| cert_manager = nova.cert.manager.CertManager | (String) DEPRECATED: Full class name for the Manager for cert |
| cert_topic = cert | (String) Determines the RPC topic that the cert nodes listen on. The default is ‘cert’, and for most deployments there is no need to ever change it. Possible values: Any string. * Services which consume this: nova-cert * Related options: None |
| crl_file = crl.pem | (String) Filename of root Certificate Revocation List |
| key_file = private/cakey.pem | (String) Filename of private key |
| keys_path = $state_path/keys | (String) Where we keep our keys |
| project_cert_subject = /C=US/ST=California/O=OpenStack/OU=NovaDev/CN=project-ca-%.16s-%s | (String) Subject for certificate for projects, %s for project, timestamp |
| use_project_ca = False | (Boolean) Should we use a CA for each project? |
| user_cert_subject = /C=US/ST=California/O=OpenStack/OU=NovaDev/CN=%.16s-%.16s-%s | (String) Subject for certificate for users, %s for project, user, timestamp |
| Configuration option = Default value | Description |
|---|---|
| [cache] | |
| backend = dogpile.cache.null | (String) Dogpile.cache backend module. It is recommended that Memcache with pooling (oslo_cache.memcache_pool) or Redis (dogpile.cache.redis) be used in production deployments. Small workloads (single process) like devstack can use the dogpile.cache.memory backend. |
| backend_argument = [] | (Multi-valued) Arguments supplied to the backend module. Specify this option once per argument to be passed to the dogpile.cache backend. Example format: “<argname>:<value>”. |
| config_prefix = cache.oslo | (String) Prefix for building the configuration dictionary for the cache region. This should not need to be changed unless there is another dogpile.cache region with the same configuration name. |
| debug_cache_backend = False | (Boolean) Extra debugging from the cache backend (cache keys, get/set/delete/etc calls). This is only really useful if you need to see the specific cache-backend get/set/delete calls with the keys/values. Typically this should be left set to false. |
| enabled = False | (Boolean) Global toggle for caching. |
| expiration_time = 600 | (Integer) Default TTL, in seconds, for any cached item in the dogpile.cache region. This applies to any cached method that doesn’t have an explicit cache expiration time defined for it. |
| memcache_dead_retry = 300 | (Integer) Number of seconds memcached server is considered dead before it is tried again. (dogpile.cache.memcache and oslo_cache.memcache_pool backends only). |
| memcache_pool_connection_get_timeout = 10 | (Integer) Number of seconds that an operation will wait to get a memcache client connection. |
| memcache_pool_maxsize = 10 | (Integer) Max total number of open connections to every memcached server. (oslo_cache.memcache_pool backend only). |
| memcache_pool_unused_timeout = 60 | (Integer) Number of seconds a connection to memcached is held unused in the pool before it is closed. (oslo_cache.memcache_pool backend only). |
| memcache_servers = localhost:11211 | (List) Memcache servers in the format of “host:port”. (dogpile.cache.memcache and oslo_cache.memcache_pool backends only). |
| memcache_socket_timeout = 3 | (Integer) Timeout in seconds for every call to a server. (dogpile.cache.memcache and oslo_cache.memcache_pool backends only). |
| proxies = | (List) Proxy classes to import that will affect the way the dogpile.cache backend functions. See the dogpile.cache documentation on changing-backend-behavior. |
| Configuration option = Default value | Description |
|---|---|
| [cells] | |
| call_timeout = 60 | (Integer) Call timeout Cell messaging module waits for response(s) to be put into the eventlet queue. This option defines the seconds waited for response from a call to a cell. Possible values: * Time in seconds. Services which consume this: * nova-cells Related options: * None |
| capabilities = hypervisor=xenserver;kvm, os=linux;windows | (List) Cell capabilities List of arbitrary key=value pairs defining capabilities of the current cell to be sent to the parent cells. These capabilities are intended to be used in cells scheduler filters/weighers. Possible values: * key=value pairs list for example; hypervisor=xenserver;kvm,os=linux;windows Services which consume this: * nova-cells Related options: * None |
| cell_type = compute | (String) Type of cell When cells feature is enabled the hosts in the OpenStack Compute cloud are partitioned into groups. Cells are configured as a tree. The top-level cell’s cell_type must be set to api. All other cells are defined as a compute cell by default. Possible values: * api: Cell type of top-level cell. * compute: Cell type of all child cells. (Default) Services which consume this: * nova-cells Related options: * compute_api_class: This option must be set to cells api driver for the top-level cell (nova.compute.cells_api.ComputeCellsAPI) * quota_driver: Disable quota checking for the child cells. (nova.quota.NoopQuotaDriver) |
| cells_config = None | (String) Optional cells configuration Configuration file from which to read cells configuration. If given, overrides reading cells from the database. Cells store all inter-cell communication data, including user names and passwords, in the database. Because the cells data is not updated very frequently, use this option to specify a JSON file to store cells data. With this configuration, the database is no longer consulted when reloading the cells data. The file must have columns present in the Cell model (excluding common database fields and the id column). You must specify the queue connection information through a transport_url field, instead of username, password, and so on. The transport_url has the following form: rabbit://USERNAME:PASSWORD@HOSTNAME:PORT/VIRTUAL_HOST Possible values: The scheme can be either qpid or rabbit, the following sample shows this optional configuration: { “parent”: { “name”: “parent”, “api_url”: “http://api.example.com:8774”, “transport_url”: “rabbit://rabbit.example.com”, “weight_offset”: 0.0, “weight_scale”: 1.0, “is_parent”: true }, “cell1”: { “name”: “cell1”, “api_url”: “http://api.example.com:8774”, “transport_url”: “rabbit://rabbit1.example.com”, “weight_offset”: 0.0, “weight_scale”: 1.0, “is_parent”: false }, “cell2”: { “name”: “cell2”, “api_url”: “http://api.example.com:8774”, “transport_url”: “rabbit://rabbit2.example.com”, “weight_offset”: 0.0, “weight_scale”: 1.0, “is_parent”: false } } Services which consume this: * nova-cells Related options: * None |
| db_check_interval = 60 | (Integer) DB check interval Cell state manager updates cell status for all cells from the DB only after this particular interval time is passed. Otherwise cached status are used. If this value is 0 or negative all cell status are updated from the DB whenever a state is needed. Possible values: * Interval time, in seconds. Services which consume this: * nova-cells Related options: * None |
| driver = nova.cells.rpc_driver.CellsRPCDriver | (String) Cells communication driver Driver for cell<->cell communication via RPC. This is used to setup the RPC consumers as well as to send a message to another cell. ‘nova.cells.rpc_driver.CellsRPCDriver’ starts up 2 separate servers for handling inter-cell communication via RPC. Possible values: * ‘nova.cells.rpc_driver.CellsRPCDriver’ is the default driver * Otherwise it should be the full Python path to the class to be used Services which consume this: * nova-cells Related options: * None |
| enable = False | (Boolean) Enable cell functionality When this functionality is enabled, it lets you to scale an OpenStack Compute cloud in a more distributed fashion without having to use complicated technologies like database and message queue clustering. Cells are configured as a tree. The top-level cell should have a host that runs a nova-api service, but no nova-compute services. Each child cell should run all of the typical nova-* services in a regular Compute cloud except for nova-api. You can think of cells as a normal Compute deployment in that each cell has its own database server and message queue broker. Possible values: * True: Enables the feature * False: Disables the feature Services which consume this: * nova-api * nova-cells * nova-compute Related options: * name: A unique cell name must be given when this functionality is enabled. * cell_type: Cell type should be defined for all cells. |
| instance_update_num_instances = 1 | (Integer) Instance update num instances On every run of the periodic task, nova cells manager will attempt to sync instance_updated_at_threshold number of instances. When the manager gets the list of instances, it shuffles them so that multiple nova-cells services do not attempt to sync the same instances in lockstep. Possible values: * Positive integer number Services which consume this: * nova-cells Related options: * This value is used with the instance_updated_at_threshold value in a periodic task run. |
| instance_update_sync_database_limit = 100 | (Integer) Instance update sync database limit Number of instances to pull from the database at one time for a sync. If there are more instances to update the results will be paged through. Possible values: * Number of instances. Services which consume this: * nova-cells Related options: * None |
| instance_updated_at_threshold = 3600 | (Integer) Instance updated at threshold Number of seconds after an instance was updated or deleted to continue to update cells. This option lets cells manager to only attempt to sync instances that have been updated recently. i.e., a threshold of 3600 means to only update instances that have modified in the last hour. Possible values: * Threshold in seconds Services which consume this: * nova-cells Related options: * This value is used with the instance_update_num_instances value in a periodic task run. |
| manager = nova.cells.manager.CellsManager | (String) DEPRECATED: Manager for cells The nova-cells manager class. This class defines RPC methods that the local cell may call. This class is NOT used for messages coming from other cells. That communication is driver-specific. Communication to other cells happens via the nova.cells.messaging module. The MessageRunner from that module will handle routing the message to the correct cell via the communication driver. Most methods below create ‘targeted’ (where we want to route a message to a specific cell) or ‘broadcast’ (where we want a message to go to multiple cells) messages. Scheduling requests get passed to the scheduler class. Possible values: * ‘nova.cells.manager.CellsManager’ is the only possible value for this option as of the Mitaka release Services which consume this: * nova-cells Related options: * None |
| max_hop_count = 10 | (Integer) Maximum hop count When processing a targeted message, if the local cell is not the target, a route is defined between neighbouring cells. And the message is processed across the whole routing path. This option defines the maximum hop counts until reaching the target. Possible values: * Positive integer value Services which consume this: * nova-cells Related options: * None |
| mute_child_interval = 300 | (Integer) Mute child interval Number of seconds after which a lack of capability and capacity update the child cell is to be treated as a mute cell. Then the child cell will be weighed as recommend highly that it be skipped. Possible values: * Time in seconds. Services which consume this: * nova-cells Related options: * None |
| mute_weight_multiplier = -10000.0 | (Floating point) Mute weight multiplier Multiplier used to weigh mute children. Mute children cells are recommended to be skipped so their weight is multiplied by this negative value. Possible values: * Negative numeric number Services which consume this: * nova-cells Related options: * None |
| name = nova | (String) Name of the current cell This value must be unique for each cell. Name of a cell is used as its id, leaving this option unset or setting the same name for two or more cells may cause unexpected behaviour. Possible values: * Unique name string Services which consume this: * nova-cells Related options: * enabled: This option is meaningful only when cells service is enabled |
| offset_weight_multiplier = 1.0 | (Floating point) Offset weight multiplier Multiplier used to weigh offset weigher. Cells with higher weight_offsets in the DB will be preferred. The weight_offset is a property of a cell stored in the database. It can be used by a deployer to have scheduling decisions favor or disfavor cells based on the setting. Possible values: * Numeric multiplier Services which consume this: * nova-cells Related options: * None |
| reserve_percent = 10.0 | (Floating point) Reserve percentage Percentage of cell capacity to hold in reserve, so the minimum amount of free resource is considered to be; min_free = total * (reserve_percent / 100.0) This option affects both memory and disk utilization. The primary purpose of this reserve is to ensure some space is available for users who want to resize their instance to be larger. Note that currently once the capacity expands into this reserve space this option is ignored. Possible values: * Float percentage value Services which consume this: * nova-cells Related options: * None |
| rpc_driver_queue_base = cells.intercell | (String) RPC driver queue base When sending a message to another cell by JSON-ifying the message and making an RPC cast to ‘process_message’, a base queue is used. This option defines the base queue name to be used when communicating between cells. Various topics by message type will be appended to this. Possible values: * The base queue name to be used when communicating between cells. Services which consume this: * nova-cells Related options: * None |
| topic = cells | (String) Topic This is the message queue topic that cells nodes listen on. It is used when the cells service is started up to configure the queue, and whenever an RPC call to the scheduler is made. Possible values: * cells: This is the recommended and the default value. Services which consume this: * nova-cells Related options: * None |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| bindir = /usr/local/bin | (String) Directory where nova binaries are installed |
| compute_topic = compute | (String) The topic compute nodes listen on |
| console_topic = console | (String) The topic console proxy nodes listen on |
| consoleauth_topic = consoleauth | (String) The topic console auth proxy nodes listen on |
| executor_thread_pool_size = 64 | (Integer) Size of executor thread pool. |
| host = localhost | (String) Name of this node. This can be an opaque identifier. It is not necessarily a hostname, FQDN, or IP address. However, the node name must be valid within an AMQP key, and if using ZeroMQ, a valid hostname, FQDN, or IP address |
| memcached_servers = None | (Unknown) DEPRECATED: Memcached servers or None for in process cache. “memcached_servers” opt is deprecated in Mitaka. In Newton release oslo.cache config options should be used as this option will be removed. Please add a [cache] group in your nova.conf file and add “enable” and “memcache_servers” option in this section. |
| my_ip = 10.0.0.1 | (String) IP address of this host |
| notify_api_faults = False | (Boolean) If set, send api.fault notifications on caught exceptions in the API service. |
| notify_on_state_change = None | (String) If set, send compute.instance.update notifications on instance state changes. Valid values are None for no notifications, “vm_state” for notifications on VM state changes, or “vm_and_task_state” for notifications on VM and task state changes. |
| pybasedir = /usr/lib/python/site-packages/nova | (String) Directory where the nova python module is installed |
| report_interval = 10 | (Integer) Seconds between nodes reporting state to datastore |
| rootwrap_config = /etc/nova/rootwrap.conf | (String) Path to the rootwrap configuration file to use for running commands as root |
| service_down_time = 60 | (Integer) Maximum time since last check-in for up service |
| state_path = $pybasedir | (String) Top-level directory for maintaining nova’s state |
| tempdir = None | (String) Explicitly specify the temporary working directory |
| use_rootwrap_daemon = False | (Boolean) Start and use a daemon that can run the commands that need to be run with root privileges. This option is usually enabled on nodes that run nova compute processes |
| [keystone_authtoken] | |
| memcached_servers = None | (List) Optionally specify a list of memcached server(s) to use for caching. If left undefined, tokens will instead be cached in-process. |
| [workarounds] | |
| destroy_after_evacuate = True | (Boolean) DEPRECATED: Whether to destroy instances on startup when we suspect they have previously been evacuated. This can result in data loss if undesired. See https://launchpad.net/bugs/1419785 |
| disable_libvirt_livesnapshot = True | (Boolean) When using libvirt 1.2.2 live snapshots fail intermittently under load. This config option provides a mechanism to enable live snapshot while this is resolved. See https://bugs.launchpad.net/nova/+bug/1334398 |
| disable_rootwrap = False | (Boolean) This option allows a fallback to sudo for performance reasons. For example see https://bugs.launchpad.net/nova/+bug/1415106 |
| handle_virt_lifecycle_events = True | (Boolean) Whether or not to handle events raised from the compute driver’s ‘emit_event’ method. These are lifecycle events raised from compute drivers that implement the method. An example of a lifecycle event is an instance starting or stopping. If the instance is going through task state changes due to an API operation, like resize, the events are ignored. However, this is an advanced feature which allows the hypervisor to signal to the compute service that an unexpected state change has occurred in an instance and the instance can be shutdown automatically - which can inherently race in reboot operations or when the compute service or host is rebooted, either planned or due to an unexpected outage. Care should be taken when using this and sync_power_state_interval is negative since then if any instances are out of sync between the hypervisor and the Nova database they will have to be synchronized manually. See https://bugs.launchpad.net/bugs/1444630 |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| compute_available_monitors = None | (Multi-valued) DEPRECATED: Monitor classes available to the compute which may be specified more than once. This option is DEPRECATED and no longer used. Use setuptools entry points to list available monitor plugins. |
| compute_driver = None | (String) Defines which driver to use for controlling virtualization. Possible values: * libvirt.LibvirtDriver * xenapi.XenAPIDriver * fake.FakeDriver * ironic.IronicDriver * vmwareapi.VMwareVCDriver * hyperv.HyperVDriver Services which consume this: * nova-compute Interdependencies to other options: * None |
| compute_manager = nova.compute.manager.ComputeManager | (String) DEPRECATED: Full class name for the Manager for compute |
| compute_monitors = | (List) A list of monitors that can be used for getting compute metrics. You can use the alias/name from the setuptools entry points for nova.compute.monitors.* namespaces. If no namespace is supplied, the “cpu.” namespace is assumed for backwards-compatibility. An example value that would enable both the CPU and NUMA memory bandwidth monitors that used the virt driver variant: [“cpu.virt_driver”, “numa_mem_bw.virt_driver”] |
| compute_resources = | (List) DEPRECATED: The names of the extra resources to track. The Extensible Resource Tracker is deprecated and will be removed in the 14.0.0 release. If you use this functionality and have custom resources that are managed by the Extensible Resource Tracker, please contact the Nova development team by posting to the openstack-dev mailing list. There is no future planned support for the tracking of custom resources. |
| compute_stats_class = nova.compute.stats.Stats | (String) DEPRECATED: Class that will manage stats for the local compute host |
| console_host = localhost | (String) Console proxy host to use to connect to instances on this host. |
| console_manager = nova.console.manager.ConsoleProxyManager | (String) DEPRECATED: Full class name for the Manager for console proxy |
| default_flavor = m1.small | (String) Default flavor to use for the EC2 API only. The Nova API does not support a default flavor. |
| default_notification_level = INFO | (String) Default notification level for outgoing notifications |
| enable_instance_password = True | (Boolean) Enables returning of the instance password by the relevant server API calls such as create, rebuild or rescue, If the hypervisor does not support password injection then the password returned will not be correct |
| heal_instance_info_cache_interval = 60 | (Integer) Number of seconds between instance network information cache updates |
| image_cache_manager_interval = 2400 | (Integer) Number of seconds to wait between runs of the image cache manager. Set to -1 to disable. Setting this to 0 will run at the default rate. |
| image_cache_subdirectory_name = _base | (String) Where cached images are stored under $instances_path. This is NOT the full path - just a folder name. For per-compute-host cached images, set to _base_$my_ip |
| instance_build_timeout = 0 | (Integer) Amount of time in seconds an instance can be in BUILD before going into ERROR status. Set to 0 to disable. |
| instance_delete_interval = 300 | (Integer) Interval in seconds for retrying failed instance file deletes. Set to -1 to disable. Setting this to 0 will run at the default rate. |
| instance_usage_audit = False | (Boolean) Generate periodic compute.instance.exists notifications |
| instance_usage_audit_period = month | (String) Time period to generate instance usages for. Time period must be hour, day, month or year |
| instances_path = $state_path/instances | (String) Where instances are stored on disk |
| max_concurrent_builds = 10 | (Integer) Maximum number of instance builds to run concurrently |
| maximum_instance_delete_attempts = 5 | (Integer) The number of times to attempt to reap an instance’s files. |
| reboot_timeout = 0 | (Integer) Automatically hard reboot an instance if it has been stuck in a rebooting state longer than N seconds. Set to 0 to disable. |
| reclaim_instance_interval = 0 | (Integer) Interval in seconds for reclaiming deleted instances. It takes effect only when value is greater than 0. |
| rescue_timeout = 0 | (Integer) Automatically unrescue an instance after N seconds. Set to 0 to disable. |
| resize_confirm_window = 0 | (Integer) Automatically confirm resizes and cold migrations after N seconds. Set to 0 to disable. |
| resume_guests_state_on_host_boot = False | (Boolean) Whether to start guests that were running before the host rebooted |
| running_deleted_instance_action = reap | (String) Action to take if a running deleted instance is detected.Set to ‘noop’ to take no action. |
| running_deleted_instance_poll_interval = 1800 | (Integer) Number of seconds to wait between runs of the cleanup task. |
| running_deleted_instance_timeout = 0 | (Integer) Number of seconds after being deleted when a running instance should be considered eligible for cleanup. |
| shelved_offload_time = 0 | (Integer) Time in seconds before a shelved instance is eligible for removing from a host. -1 never offload, 0 offload immediately when shelved |
| shelved_poll_interval = 3600 | (Integer) Interval in seconds for polling shelved instances to offload. Set to -1 to disable.Setting this to 0 will run at the default rate. |
| shutdown_timeout = 60 | (Integer) Total amount of time to wait in seconds for an instance to perform a clean shutdown. |
| sync_power_state_interval = 600 | (Integer) Interval to sync power states between the database and the hypervisor. Set to -1 to disable. Setting this to 0 will run at the default rate. |
| update_resources_interval = 0 | (Integer) Interval in seconds for updating compute resources. A number less than 0 means to disable the task completely. Leaving this at the default of 0 will cause this to run at the default periodic interval. Setting it to any positive value will cause it to run at approximately that number of seconds. |
| vif_plugging_is_fatal = True | (Boolean) Determine if instance should boot or fail on VIF plugging timeout. Nova sends a port update to Neutron after an instance has been scheduled, providing Neutron with the necessary information to finish setup of the port. Once completed, Neutron notifies Nova that it has finished setting up the port, at which point Nova resumes the boot of the instance since network connectivity is now supposed to be present. A timeout will occur if the reply is not received after a given interval. This option determines what Nova does when the VIF plugging timeout event happens. When enabled, the instance will error out. When disabled, the instance will continue to boot on the assumption that the port is ready. Possible values: * True: Instances should fail after VIF plugging timeout * False: Instances should continue booting after VIF plugging timeout Services which consume this: * nova-compute Interdependencies to other options: * None |
| vif_plugging_timeout = 300 | (Integer) Timeout for Neutron VIF plugging event message arrival. Number of seconds to wait for Neutron vif plugging events to arrive before continuing or failing (see ‘vif_plugging_is_fatal’). If this is set to zero and ‘vif_plugging_is_fatal’ is False, events should not be expected to arrive at all. Possible values: * A time interval in seconds Services which consume this: * nova-compute Interdependencies to other options: * None |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| migrate_max_retries = -1 | (Integer) Number of times to retry live-migration before failing. If == -1, try until out of hosts. If == 0, only try once, no retries. |
| [conductor] | |
| manager = nova.conductor.manager.ConductorManager | (String) DEPRECATED: Full class name for the Manager for conductor. Removal in 14.0 |
| topic = conductor | (String) The topic on which conductor nodes listen |
| use_local = False | (Boolean) DEPRECATED: Perform nova-conductor operations locally. This legacy mode was introduced to bridge a gap during the transition to the conductor service. It no longer represents a reasonable alternative for deployers. Removal may be as early as 14.0 |
| workers = None | (Integer) Number of workers for OpenStack Conductor service. The default will be the number of CPUs available. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| config_drive_format = iso9660 | (String) Config drive format. |
| config_drive_skip_versions = 1.0 2007-01-19 2007-03-01 2007-08-29 2007-10-10 2007-12-15 2008-02-01 2008-09-01 | (String) List of metadata versions to skip placing into the config drive |
| force_config_drive = False | (Boolean) Force injection to take place on a config drive |
| mkisofs_cmd = genisoimage | (String) Name and optionally path of the tool used for ISO image creation |
| [hyperv] | |
| config_drive_cdrom = False | (Boolean) Attaches the Config Drive image as a cdrom drive instead of a disk drive |
| config_drive_inject_password = False | (Boolean) Sets the admin password in the config drive image |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| console_allowed_origins = | (List) Allowed Origin header hostnames for access to console proxy servers |
| console_public_hostname = localhost | (String) Publicly visible name for this console host |
| console_token_ttl = 600 | (Integer) How many seconds before deleting tokens |
| consoleauth_manager = nova.consoleauth.manager.ConsoleAuthManager | (String) DEPRECATED: Manager for console auth |
| [mks] | |
| enabled = False | (Boolean) Enable MKS related features |
| mksproxy_base_url = http://127.0.0.1:6090/ | (String) Location of MKS web console proxy, in the form “http://127.0.0.1:6090/“ |
| Configuration option = Default value | Description |
|---|---|
| [cors] | |
| allow_credentials = True | (Boolean) Indicate that the actual request can include user credentials |
| allow_headers = Content-Type, Cache-Control, Content-Language, Expires, Last-Modified, Pragma | (List) Indicate which header field names may be used during the actual request. |
| allow_methods = GET, POST, PUT, DELETE, OPTIONS | (List) Indicate which methods can be used during the actual request. |
| allowed_origin = None | (List) Indicate whether this resource may be shared with the domain received in the requests “origin” header. |
| expose_headers = Content-Type, Cache-Control, Content-Language, Expires, Last-Modified, Pragma | (List) Indicate which headers are safe to expose to the API. Defaults to HTTP Simple Headers. |
| max_age = 3600 | (Integer) Maximum cache age of CORS preflight requests. |
| [cors.subdomain] | |
| allow_credentials = True | (Boolean) Indicate that the actual request can include user credentials |
| allow_headers = Content-Type, Cache-Control, Content-Language, Expires, Last-Modified, Pragma | (List) Indicate which header field names may be used during the actual request. |
| allow_methods = GET, POST, PUT, DELETE, OPTIONS | (List) Indicate which methods can be used during the actual request. |
| allowed_origin = None | (List) Indicate whether this resource may be shared with the domain received in the requests “origin” header. |
| expose_headers = Content-Type, Cache-Control, Content-Language, Expires, Last-Modified, Pragma | (List) Indicate which headers are safe to expose to the API. Defaults to HTTP Simple Headers. |
| max_age = 3600 | (Integer) Maximum cache age of CORS preflight requests. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| db_driver = nova.db | (String) DEPRECATED: The driver to use for database access |
| [api_database] | |
| connection = None | (String) The SQLAlchemy connection string to use to connect to the Nova API database. |
| connection_debug = 0 | (Integer) Verbosity of SQL debugging information: 0=None, 100=Everything. |
| connection_trace = False | (Boolean) Add Python stack traces to SQL as comment strings. |
| idle_timeout = 3600 | (Integer) Timeout before idle SQL connections are reaped. |
| max_overflow = None | (Integer) If set, use this value for max_overflow with SQLAlchemy. |
| max_pool_size = None | (Integer) Maximum number of SQL connections to keep open in a pool. |
| max_retries = 10 | (Integer) Maximum number of database connection retries during startup. Set to -1 to specify an infinite retry count. |
| mysql_sql_mode = TRADITIONAL | (String) The SQL mode to be used for MySQL sessions. This option, including the default, overrides any server-set SQL mode. To use whatever SQL mode is set by the server configuration, set this to no value. Example: mysql_sql_mode= |
| pool_timeout = None | (Integer) If set, use this value for pool_timeout with SQLAlchemy. |
| retry_interval = 10 | (Integer) Interval between retries of opening a SQL connection. |
| slave_connection = None | (String) The SQLAlchemy connection string to use to connect to the slave database. |
| sqlite_synchronous = True | (Boolean) If True, SQLite uses synchronous mode. |
| [database] | |
| backend = sqlalchemy | (String) The back end to use for the database. |
| connection = None | (String) The SQLAlchemy connection string to use to connect to the database. |
| connection_debug = 0 | (Integer) Verbosity of SQL debugging information: 0=None, 100=Everything. |
| connection_trace = False | (Boolean) Add Python stack traces to SQL as comment strings. |
| db_inc_retry_interval = True | (Boolean) If True, increases the interval between retries of a database operation up to db_max_retry_interval. |
| db_max_retries = 20 | (Integer) Maximum retries in case of connection error or deadlock error before error is raised. Set to -1 to specify an infinite retry count. |
| db_max_retry_interval = 10 | (Integer) If db_inc_retry_interval is set, the maximum seconds between retries of a database operation. |
| db_retry_interval = 1 | (Integer) Seconds between retries of a database transaction. |
| idle_timeout = 3600 | (Integer) Timeout before idle SQL connections are reaped. |
| max_overflow = 50 | (Integer) If set, use this value for max_overflow with SQLAlchemy. |
| max_pool_size = None | (Integer) Maximum number of SQL connections to keep open in a pool. |
| max_retries = 10 | (Integer) Maximum number of database connection retries during startup. Set to -1 to specify an infinite retry count. |
| min_pool_size = 1 | (Integer) Minimum number of SQL connections to keep open in a pool. |
| mysql_sql_mode = TRADITIONAL | (String) The SQL mode to be used for MySQL sessions. This option, including the default, overrides any server-set SQL mode. To use whatever SQL mode is set by the server configuration, set this to no value. Example: mysql_sql_mode= |
| pool_timeout = None | (Integer) If set, use this value for pool_timeout with SQLAlchemy. |
| retry_interval = 10 | (Integer) Interval between retries of opening a SQL connection. |
| slave_connection = None | (String) The SQLAlchemy connection string to use to connect to the slave database. |
| sqlite_db = oslo.sqlite | (String) The file name to use with SQLite. |
| sqlite_synchronous = True | (Boolean) If True, SQLite uses synchronous mode. |
| use_db_reconnect = False | (Boolean) Enable the experimental use of database reconnect on connection lost. |
| use_tpool = False | (Boolean) Enable the experimental use of thread pooling for all DB API calls |
| Configuration option = Default value | Description |
|---|---|
| [guestfs] | |
| debug = False | (Boolean) Enable guestfs debug |
| Configuration option = Default value | Description |
|---|---|
| [ephemeral_storage_encryption] | |
| cipher = aes-xts-plain64 | (String) The cipher and mode to be used to encrypt ephemeral storage. Which ciphers are available ciphers depends on kernel support. See /proc/crypto for the list of available options. |
| enabled = False | (Boolean) Whether to encrypt ephemeral storage |
| key_size = 512 | (Integer) The bit length of the encryption key to be used to encrypt ephemeral storage (in XTS mode only half of the bits are used for encryption key) |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| fping_path = /usr/sbin/fping | (String) Full path to fping. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| osapi_glance_link_prefix = None | (String) Base URL that will be presented to users in links to glance resources |
| [glance] | |
| allowed_direct_url_schemes = | (List) A list of url scheme that can be downloaded directly via the direct_url. Currently supported schemes: [file]. |
| api_insecure = False | (Boolean) Allow to perform insecure SSL (https) requests to glance |
| api_servers = None | (List) A list of the glance api servers endpoints available to nova. These should be fully qualified urls of the form “scheme://hostname:port[/path]” (i.e. “http://10.0.1.0:9292” or “https://my.glance.server/image”) |
| host = $my_ip | (String) DEPRECATED: Glance server hostname or IP address. Use the “api_servers” option instead. |
| num_retries = 0 | (Integer) Number of retries when uploading / downloading an image to / from glance. |
| port = 9292 | (Integer) DEPRECATED: Glance server port. Use the “api_servers” option instead. |
| protocol = http | (String) DEPRECATED: Protocol to use when connecting to glance. Set to https for SSL. Use the “api_servers” option instead. |
| verify_glance_signatures = False | (Boolean) Require Nova to perform signature verification on each image downloaded from Glance. |
| [image_file_url] | |
| filesystems = | (List) List of file systems that are configured in this file in the image_file_url:<list entry name> sections |
| Configuration option = Default value | Description |
|---|---|
| [hyperv] | |
| dynamic_memory_ratio = 1.0 | (Floating point) Dynamic memory ratio Enables dynamic memory allocation (ballooning) when set to a value greater than 1. The value expresses the ratio between the total RAM assigned to an instance and its startup RAM amount. For example a ratio of 2.0 for an instance with 1024MB of RAM implies 512MB of RAM allocated at startup. Possible values: * 1.0: Disables dynamic memory allocation (Default). * Float values greater than 1.0: Enables allocation of total implied RAM divided by this value for startup. Services which consume this: * nova-compute Related options: * None |
| enable_instance_metrics_collection = False | (Boolean) Enable instance metrics collection Enables metrics collections for an instance by using Hyper-V’s metric APIs. Collected data can by retrieved by other apps and services, e.g.: Ceilometer. Possible values: * True: Enables metrics collection. * False: Disables metric collection (Default). Services which consume this: * nova-compute Related options: * None |
| instances_path_share = | (String) Instances path share The name of a Windows share mapped to the “instances_path” dir and used by the resize feature to copy files to the target host. If left blank, an administrative share (hidden network share) will be used, looking for the same “instances_path” used locally. Possible values: * “”: An administrative share will be used (Default). * Name of a Windows share. Services which consume this: * nova-compute Related options: * “instances_path”: The directory which will be used if this option here is left blank. |
| limit_cpu_features = False | (Boolean) Limit CPU features This flag is needed to support live migration to hosts with different CPU features and checked during instance creation in order to limit the CPU features used by the instance. Possible values: * True: Limit processor-specific features. * False: Do not limit processor-specific features (Default). Services which consume this: * nova-compute Related options: * None |
| mounted_disk_query_retry_count = 10 | (Integer) The number of times to retry checking for a disk mounted via iSCSI. |
| mounted_disk_query_retry_interval = 5 | (Integer) Interval between checks for a mounted iSCSI disk, in seconds. |
| power_state_check_timeframe = 60 | (Integer) The timeframe to be checked for instance power state changes. |
| power_state_event_polling_interval = 2 | (Integer) Instance power state change event polling frequency. |
| qemu_img_cmd = qemu-img.exe | (String) Path of qemu-img command which is used to convert between different image types |
| vswitch_name = None | (String) External virtual switch Name, if not provided, the first external virtual switch is used |
| wait_soft_reboot_seconds = 60 | (Integer) Number of seconds to wait for instance to shut down after soft reboot request is made. We fall back to hard reboot if instance does not shutdown within this window. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| default_ephemeral_format = None | (String) The default format an ephemeral_volume will be formatted with on creation. Possible values: * ext2 * ext3 * ext4 * xfs * ntfs (only for Windows guests) Services which consume this: * nova-compute Interdependencies to other options: * None |
| force_raw_images = True | (Boolean) Force conversion of backing images to raw format. Possible values: * True: Backing image files will be converted to raw image format * False: Backing image files will not be converted Services which consume this: * nova-compute Interdependencies to other options: * compute_driver: Only the libvirt driver uses this option. |
| preallocate_images = none | (String) The image preallocation mode to use. Image preallocation allows storage for instance images to be allocated up front when the instance is initially provisioned. This ensures immediate feedback is given if enough space isn’t available. In addition, it should significantly improve performance on writes to new blocks and may even improve I/O performance to prewritten blocks due to reduced fragmentation. Possible values: * “none” => no storage provisioning is done up front * “space” => storage is fully allocated at instance start Services which consume this: * nova-compute Interdependencies to other options: * None |
| timeout_nbd = 10 | (Integer) Amount of time, in seconds, to wait for NBD device start up. |
| use_cow_images = True | (Boolean) Enable use of copy-on-write (cow) images. QEMU/KVM allow the use of qcow2 as backing files. By disabling this, backing files will not be used. Possible values: * True: Enable use of cow images * False: Disable use of cow images Services which consume this: * nova-compute Interdependencies to other options: * None |
| vcpu_pin_set = None | (String) Defines which physical CPUs (pCPUs) can be used by instance virtual CPUs (vCPUs). Possible values: * A comma-separated list of physical CPU numbers that virtual CPUs can be allocated to by default. Each element should be either a single CPU number, a range of CPU numbers, or a caret followed by a CPU number to be excluded from a previous range. For example: vcpu_pin_set = “4-12,^8,15” Services which consume this: * nova-scheduler * nova-compute Interdependencies to other options: * None |
| virt_mkfs = [] | (Multi-valued) Name of the mkfs commands for ephemeral device. The format is <os_type>=<mkfs command> |
| Configuration option = Default value | Description |
|---|---|
| [ironic] | |
| admin_auth_token = None | (String) DEPRECATED: Ironic keystone auth token.DEPRECATED: use admin_username, admin_password, and admin_tenant_name instead |
| admin_password = None | (String) Ironic keystone admin password. |
| admin_tenant_name = None | (String) Ironic keystone tenant name. |
| admin_url = None | (String) Keystone public API endpoint. |
| admin_username = None | (String) Ironic keystone admin name |
| api_endpoint = None | (String) URL for Ironic API endpoint. |
| api_max_retries = 60 | (Integer) How many retries when a request does conflict. If <= 0, only try once, no retries. |
| api_retry_interval = 2 | (Integer) How often to retry in seconds when a request does conflict |
| api_version = 1 | (Integer) DEPRECATED: Version of Ironic API service endpoint. DEPRECATED: Setting the API version is not possible anymore. |
| cafile = None | (String) PEM encoded Certificate Authority to use when verifying HTTPs connections. |
| client_log_level = None | (String) DEPRECATED: Log level override for ironicclient. Set this in order to override the global “default_log_levels”, “verbose”, and “debug” settings. DEPRECATED: use standard logging configuration. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| fixed_range_v6 = fd00::/48 | (String) Fixed IPv6 address block |
| gateway_v6 = None | (String) Default IPv6 gateway |
| ipv6_backend = rfc2462 | (String) Backend to use for IPv6 generation |
| use_ipv6 = False | (Boolean) Use IPv6 |
| Configuration option = Default value | Description |
|---|---|
| [keymgr] | |
| api_class = nova.keymgr.conf_key_mgr.ConfKeyManager | (String) The full class name of the key manager API class |
| fixed_key = None | (String) Fixed key returned by key manager, specified in hex |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| ldap_dns_base_dn = ou=hosts,dc=example,dc=org | (String) Base DN for DNS entries in LDAP |
| ldap_dns_password = password | (String) Password for LDAP DNS |
| ldap_dns_servers = ['dns.example.org'] | (Multi-valued) DNS Servers for LDAP DNS driver |
| ldap_dns_soa_expiry = 86400 | (String) Expiry interval (in seconds) for LDAP DNS driver Statement of Authority |
| ldap_dns_soa_hostmaster = hostmaster@example.org | (String) Hostmaster for LDAP DNS driver Statement of Authority |
| ldap_dns_soa_minimum = 7200 | (String) Minimum interval (in seconds) for LDAP DNS driver Statement of Authority |
| ldap_dns_soa_refresh = 1800 | (String) Refresh interval (in seconds) for LDAP DNS driver Statement of Authority |
| ldap_dns_soa_retry = 3600 | (String) Retry interval (in seconds) for LDAP DNS driver Statement of Authority |
| ldap_dns_url = ldap://ldap.example.com:389 | (String) URL for LDAP server which will store DNS entries |
| ldap_dns_user = uid=admin,ou=people,dc=example,dc=org | (String) User for LDAP DNS |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| remove_unused_base_images = True | (Boolean) Should unused base images be removed? |
| remove_unused_original_minimum_age_seconds = 86400 | (Integer) Unused unresized base images younger than this will not be removed |
| [libvirt] | |
| block_migration_flag = VIR_MIGRATE_UNDEFINE_SOURCE, VIR_MIGRATE_PEER2PEER, VIR_MIGRATE_LIVE, VIR_MIGRATE_TUNNELLED, VIR_MIGRATE_NON_SHARED_INC | (String) DEPRECATED: Migration flags to be set for block migration The correct block migration flags can be inferred from the new live_migration_tunnelled config option. block_migration_flag will be removed to avoid potential misconfiguration. |
| checksum_base_images = False | (Boolean) Write a checksum for files in _base to disk |
| checksum_interval_seconds = 3600 | (Integer) How frequently to checksum base images |
| connection_uri = | (String) Override the default libvirt URI (which is dependent on virt_type) |
| cpu_mode = None | (String) Set to “host-model” to clone the host CPU feature flags; to “host-passthrough” to use the host CPU model exactly; to “custom” to use a named CPU model; to “none” to not set any CPU model. If virt_type=”kvm|qemu”, it will default to “host-model”, otherwise it will default to “none” |
| cpu_model = None | (String) Set to a named libvirt CPU model (see names listed in /usr/share/libvirt/cpu_map.xml). Only has effect if cpu_mode=”custom” and virt_type=”kvm|qemu” |
| disk_cachemodes = | (List) Specific cachemodes to use for different disk types e.g: file=directsync,block=none |
| disk_prefix = None | (String) Override the default disk prefix for the devices attached to a server, which is dependent on virt_type. (valid options are: sd, xvd, uvd, vd) |
| gid_maps = | (List) List of guid targets and ranges.Syntax is guest-gid:host-gid:countMaximum of 5 allowed. |
| hw_disk_discard = None | (String) Discard option for nova managed disks. Need Libvirt(1.0.6) Qemu1.5 (raw format) Qemu1.6(qcow2 format) |
| hw_machine_type = None | (List) For qemu or KVM guests, set this option to specify a default machine type per host architecture. You can find a list of supported machine types in your environment by checking the output of the “virsh capabilities”command. The format of the value for this config option is host-arch=machine-type. For example: x86_64=machinetype1,armv7l=machinetype2 |
| image_info_filename_pattern = $instances_path/$image_cache_subdirectory_name/%(image)s.info | (String) Allows image information files to be stored in non-standard locations |
| images_rbd_ceph_conf = | (String) Path to the ceph configuration file to use |
| images_rbd_pool = rbd | (String) The RADOS pool in which rbd volumes are stored |
| images_type = default | (String) VM Images format. If default is specified, then use_cow_images flag is used instead of this one. |
| images_volume_group = None | (String) LVM Volume Group that is used for VM images, when you specify images_type=lvm. |
| inject_key = False | (Boolean) Inject the ssh public key at boot time |
| inject_partition = -2 | (Integer) The partition to inject to : -2 => disable, -1 => inspect (libguestfs only), 0 => not partitioned, >0 => partition number |
| inject_password = False | (Boolean) Inject the admin password at boot time, without an agent. |
| iscsi_iface = None | (String) The iSCSI transport iface to use to connect to target in case offload support is desired. Default format is of the form <transport_name>.<hwaddress> where <transport_name> is one of (be2iscsi, bnx2i, cxgb3i, cxgb4i, qla4xxx, ocs) and <hwaddress> is the MAC address of the interface and can be generated via the iscsiadm -m iface command. Do not confuse the iscsi_iface parameter to be provided here with the actual transport name. |
| iscsi_use_multipath = False | (Boolean) Use multipath connection of the iSCSI or FC volume |
| iser_use_multipath = False | (Boolean) Use multipath connection of the iSER volume |
| mem_stats_period_seconds = 10 | (Integer) A number of seconds to memory usage statistics period. Zero or negative value mean to disable memory usage statistics. |
| realtime_scheduler_priority = 1 | (Integer) In a realtime host context vCPUs for guest will run in that scheduling priority. Priority depends on the host kernel (usually 1-99) |
| remove_unused_kernels = True | (Boolean) DEPRECATED: Should unused kernel images be removed? This is only safe to enable if all compute nodes have been updated to support this option (running Grizzly or newer level compute). This will be the default behavior in the 13.0.0 release. |
| remove_unused_resized_minimum_age_seconds = 3600 | (Integer) Unused resized base images younger than this will not be removed |
| rescue_image_id = None | (String) Rescue ami image. This will not be used if an image id is provided by the user. |
| rescue_kernel_id = None | (String) Rescue aki image |
| rescue_ramdisk_id = None | (String) Rescue ari image |
| rng_dev_path = None | (String) A path to a device that will be used as source of entropy on the host. Permitted options are: /dev/random or /dev/hwrng |
| snapshot_compression = False | (Boolean) Compress snapshot images when possible. This currently applies exclusively to qcow2 images |
| snapshot_image_format = None | (String) Snapshot image format. Defaults to same as source image |
| snapshots_directory = $instances_path/snapshots | (String) Location where libvirt driver will store snapshots before uploading them to image service |
| sparse_logical_volumes = False | (Boolean) Create sparse logical volumes (with virtualsize) if this flag is set to True. |
| sysinfo_serial = auto | (String) The data source used to the populate the host “serial” UUID exposed to guest in the virtual BIOS. |
| uid_maps = | (List) List of uid targets and ranges.Syntax is guest-uid:host-uid:countMaximum of 5 allowed. |
| use_usb_tablet = True | (Boolean) Sync virtual and real mouse cursors in Windows VMs |
| use_virtio_for_bridges = True | (Boolean) Use virtio for bridge interfaces with KVM/QEMU |
| virt_type = kvm | (String) Libvirt domain type |
| volume_clear = zero | (String) Method used to wipe old volumes. |
| volume_clear_size = 0 | (Integer) Size in MiB to wipe at start of old volumes. 0 => all |
| wait_soft_reboot_seconds = 120 | (Integer) Number of seconds to wait for instance to shut down after soft reboot request is made. We fall back to hard reboot if instance does not shutdown within this window. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| live_migration_retry_count = 30 | (Integer) Number of 1 second retries needed in live_migration |
| max_concurrent_live_migrations = 1 | (Integer) Maximum number of live migrations to run concurrently. This limit is enforced to avoid outbound live migrations overwhelming the host/network and causing failures. It is not recommended that you change this unless you are very sure that doing so is safe and stable in your environment. |
| [libvirt] | |
| live_migration_bandwidth = 0 | (Integer) Maximum bandwidth(in MiB/s) to be used during migration. If set to 0, will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0. Please refer to the libvirt documentation for further details |
| live_migration_completion_timeout = 800 | (Integer) Time to wait, in seconds, for migration to successfully complete transferring data before aborting the operation. Value is per GiB of guest RAM + disk to be transferred, with lower bound of a minimum of 2 GiB. Should usually be larger than downtime delay * downtime steps. Set to 0 to disable timeouts. |
| live_migration_downtime = 500 | (Integer) Maximum permitted downtime, in milliseconds, for live migration switchover. Will be rounded up to a minimum of 100ms. Use a large value if guest liveness is unimportant. |
| live_migration_downtime_delay = 75 | (Integer) Time to wait, in seconds, between each step increase of the migration downtime. Minimum delay is 10 seconds. Value is per GiB of guest RAM + disk to be transferred, with lower bound of a minimum of 2 GiB per device |
| live_migration_downtime_steps = 10 | (Integer) Number of incremental steps to reach max downtime value. Will be rounded up to a minimum of 3 steps |
| live_migration_flag = VIR_MIGRATE_UNDEFINE_SOURCE, VIR_MIGRATE_PEER2PEER, VIR_MIGRATE_LIVE, VIR_MIGRATE_TUNNELLED | (String) DEPRECATED: Migration flags to be set for live migration The correct live migration flags can be inferred from the new live_migration_tunnelled config option. live_migration_flag will be removed to avoid potential misconfiguration. |
| live_migration_inbound_addr = None | (String) Live migration target ip or hostname (if this option is set to None, which is the default, the hostname of the migration target compute node will be used) |
| live_migration_progress_timeout = 150 | (Integer) Time to wait, in seconds, for migration to make forward progress in transferring data before aborting the operation. Set to 0 to disable timeouts. |
| live_migration_tunnelled = None | (Boolean) Whether to use tunnelled migration, where migration data is transported over the libvirtd connection. If True, we use the VIR_MIGRATE_TUNNELLED migration flag, avoiding the need to configure the network to allow direct hypervisor to hypervisor communication. If False, use the native transport. If not set, Nova will choose a sensible default based on, for example the availability of native encryption support in the hypervisor. |
| live_migration_uri = None | (String) Override the default libvirt live migration target URI (which is dependent on virt_type) (any included “%s” is replaced with the migration target hostname) |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| debug = False | (Boolean) If set to true, the logging level will be set to DEBUG instead of the default INFO level. |
| default_log_levels = amqp=WARN, amqplib=WARN, boto=WARN, qpid=WARN, sqlalchemy=WARN, suds=INFO, oslo.messaging=INFO, iso8601=WARN, requests.packages.urllib3.connectionpool=WARN, urllib3.connectionpool=WARN, websocket=WARN, requests.packages.urllib3.util.retry=WARN, urllib3.util.retry=WARN, keystonemiddleware=WARN, routes.middleware=WARN, stevedore=WARN, taskflow=WARN, keystoneauth=WARN, oslo.cache=INFO, dogpile.core.dogpile=INFO | (List) List of package logging levels in logger=LEVEL pairs. This option is ignored if log_config_append is set. |
| fatal_deprecations = False | (Boolean) Enables or disables fatal status of deprecations. |
| fatal_exception_format_errors = False | (Boolean) Make exception message format errors fatal |
| instance_format = "[instance: %(uuid)s] " | (String) The format for an instance that is passed with the log message. |
| instance_uuid_format = "[instance: %(uuid)s] " | (String) The format for an instance UUID that is passed with the log message. |
| log_config_append = None | (String) The name of a logging configuration file. This file is appended to any existing logging configuration files. For details about logging configuration files, see the Python logging module documentation. Note that when logging configuration files are used then all logging configuration is set in the configuration file and other logging configuration options are ignored (for example, logging_context_format_string). |
| log_date_format = %Y-%m-%d %H:%M:%S | (String) Defines the format string for %%(asctime)s in log records. Default: %(default)s . This option is ignored if log_config_append is set. |
| log_dir = None | (String) (Optional) The base directory used for relative log_file paths. This option is ignored if log_config_append is set. |
| log_file = None | (String) (Optional) Name of log file to send logging output to. If no default is set, logging will go to stderr as defined by use_stderr. This option is ignored if log_config_append is set. |
| logging_context_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [%(request_id)s %(user_identity)s] %(instance)s%(message)s | (String) Format string to use for log messages with context. |
| logging_debug_format_suffix = %(funcName)s %(pathname)s:%(lineno)d | (String) Additional data to append to log message when logging level for the message is DEBUG. |
| logging_default_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [-] %(instance)s%(message)s | (String) Format string to use for log messages when context is undefined. |
| logging_exception_prefix = %(asctime)s.%(msecs)03d %(process)d ERROR %(name)s %(instance)s | (String) Prefix each line of exception output with this format. |
| logging_user_identity_format = %(user)s %(tenant)s %(domain)s %(user_domain)s %(project_domain)s | (String) Defines the format string for %(user_identity)s that is used in logging_context_format_string. |
| publish_errors = False | (Boolean) Enables or disables publication of error events. |
| syslog_log_facility = LOG_USER | (String) Syslog facility to receive log lines. This option is ignored if log_config_append is set. |
| use_stderr = True | (Boolean) Log output to standard error. This option is ignored if log_config_append is set. |
| use_syslog = False | (Boolean) Use syslog for logging. Existing syslog format is DEPRECATED and will be changed later to honor RFC5424. This option is ignored if log_config_append is set. |
| verbose = True | (Boolean) DEPRECATED: If set to false, the logging level will be set to WARNING instead of the default INFO level. |
| watch_log_file = False | (Boolean) Uses logging handler designed to watch file system. When log file is moved or removed this handler will open a new log file with specified path instantaneously. It makes sense only if log_file option is specified and Linux platform is used. This option is ignored if log_config_append is set. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| metadata_cache_expiration = 15 | (Integer) Time in seconds to cache metadata; 0 to disable metadata caching entirely (not recommended). Increasingthis should improve response times of the metadata API when under heavy load. Higher values may increase memoryusage and result in longer times for host metadata changes to take effect. |
| metadata_host = $my_ip | (String) The IP address for the metadata API server |
| metadata_listen = 0.0.0.0 | (String) The IP address on which the metadata API will listen. |
| metadata_listen_port = 8775 | (Integer) The port on which the metadata API will listen. |
| metadata_manager = nova.api.manager.MetadataManager | (String) DEPRECATED: OpenStack metadata service manager |
| metadata_port = 8775 | (Integer) The port for the metadata API port |
| metadata_workers = None | (Integer) Number of workers for metadata service. The default will be the number of CPUs available. |
| vendordata_driver = nova.api.metadata.vendordata_json.JsonFileVendorData | (String) DEPRECATED: Driver to use for vendor data |
| vendordata_jsonfile_path = None | (String) File to load JSON formatted vendor data from |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| allow_same_net_traffic = True | (Boolean) Determine whether to allow network traffic from same network. When set to true, hosts on the same subnet are not filtered and are allowed to pass all types of traffic between them. On a flat network, this allows all instances from all projects unfiltered communication. With VLAN networking, this allows access between instances within the same project. This option only applies when using the nova-network service. When using another networking services, such as Neutron, security groups or other approaches should be used. Possible values: * True: Network traffic should be allowed pass between all instances on the same network, regardless of their tenant and security policies * False: Network traffic should not be allowed pass between instances unless it is unblocked in a security group Services which consume this: * nova-network Interdependencies to other options: * use_neutron: This must be set to False to enable nova-network networking * firewall_driver: This must be set to nova.virt.libvirt.firewall.IptablesFirewallDriver to ensure the libvirt firewall driver is enabled. |
| auto_assign_floating_ip = False | (Boolean) Autoassigning floating IP to VM |
| cnt_vpn_clients = 0 | (Integer) Number of addresses reserved for vpn clients |
| create_unique_mac_address_attempts = 5 | (Integer) Number of attempts to create unique mac address |
| default_access_ip_network_name = None | (String) Name of network to use to set access IPs for instances |
| default_floating_pool = nova | (String) Default pool for floating IPs |
| defer_iptables_apply = False | (Boolean) Whether to batch up the application of IPTables rules during a host restart and apply all at the end of the init phase |
| dhcp_domain = novalocal | (String) Domain to use for building the hostnames |
| dhcp_lease_time = 86400 | (Integer) Lifetime of a DHCP lease in seconds |
| dhcpbridge = $bindir/nova-dhcpbridge | (String) Location of nova-dhcpbridge |
| dhcpbridge_flagfile = ['/etc/nova/nova-dhcpbridge.conf'] | (Multi-valued) Location of flagfiles for dhcpbridge |
| dns_server = [] | (Multi-valued) If set, uses specific DNS server for dnsmasq. Can be specified multiple times. |
| dns_update_periodic_interval = -1 | (Integer) Number of seconds to wait between runs of updates to DNS entries. |
| dnsmasq_config_file = | (String) Override the default dnsmasq settings with this file |
| ebtables_exec_attempts = 3 | (Integer) Number of times to retry ebtables commands on failure. |
| ebtables_retry_interval = 1.0 | (Floating point) Number of seconds to wait between ebtables retries. |
| firewall_driver = None | (String) Firewall driver to use with nova-network service. This option only applies when using the nova-network service. When using another networking services, such as Neutron, this should be to set to the NoopFirewallDriver. If unset (the default), this will default to the hypervisor-specified default driver. Possible values: * nova.virt.firewall.IptablesFirewallDriver * nova.virt.firewall.NoopFirewallDriver * nova.virt.libvirt.firewall.IptablesFirewallDriver * [...] Services which consume this: * nova-network Interdependencies to other options: * use_neutron: This must be set to False to enable nova-network networking |
| fixed_ip_disassociate_timeout = 600 | (Integer) Seconds after which a deallocated IP is disassociated |
| flat_injected = False | (Boolean) Whether to attempt to inject network setup into guest |
| flat_interface = None | (String) FlatDhcp will bridge into this interface if set |
| flat_network_bridge = None | (String) Bridge for simple network instances |
| flat_network_dns = 8.8.4.4 | (String) DNS server for simple network |
| floating_ip_dns_manager = nova.network.noop_dns_driver.NoopDNSDriver | (String) Full class name for the DNS Manager for floating IPs |
| force_dhcp_release = True | (Boolean) If True, send a dhcp release on instance termination |
| force_snat_range = [] | (Multi-valued) Traffic to this range will always be snatted to the fallback IP, even if it would normally be bridged out of the node. Can be specified multiple times. |
| forward_bridge_interface = ['all'] | (Multi-valued) An interface that bridges can forward to. If this is set to all then all traffic will be forwarded. Can be specified multiple times. |
| gateway = None | (String) Default IPv4 gateway |
| injected_network_template = $pybasedir/nova/virt/interfaces.template | (String) Template file for injected network |
| instance_dns_domain = | (String) Full class name for the DNS Zone for instance IPs |
| instance_dns_manager = nova.network.noop_dns_driver.NoopDNSDriver | (String) Full class name for the DNS Manager for instance IPs |
| iptables_bottom_regex = | (String) Regular expression to match the iptables rule that should always be on the bottom. |
| iptables_drop_action = DROP | (String) The table that iptables to jump to when a packet is to be dropped. |
| iptables_top_regex = | (String) Regular expression to match the iptables rule that should always be on the top. |
| l3_lib = nova.network.l3.LinuxNetL3 | (String) Indicates underlying L3 management library |
| linuxnet_interface_driver = nova.network.linux_net.LinuxBridgeInterfaceDriver | (String) Driver used to create ethernet devices. |
| linuxnet_ovs_integration_bridge = br-int | (String) Name of Open vSwitch bridge used with linuxnet |
| multi_host = False | (Boolean) Default value for multi_host in networks. Also, if set, some rpc network calls will be sent directly to host. |
| network_allocate_retries = 0 | (Integer) Number of times to retry network allocation on failures |
| network_api_class = nova.network.api.API | (String) DEPRECATED: The full class name of the network API class to use. use_neutron should be used instead. |
| network_device_mtu = None | (Integer) DEPRECATED: THIS VALUE SHOULD BE SET WHEN CREATING THE NETWORK. MTU setting for network interface. |
| network_driver = nova.network.linux_net | (String) Driver to use for network creation |
| network_manager = nova.network.manager.VlanManager | (String) Full class name for the Manager for network |
| network_size = 256 | (Integer) Number of addresses in each private subnet |
| network_topic = network | (String) The topic network nodes listen on |
| networks_path = $state_path/networks | (String) Location to keep network config files |
| num_networks = 1 | (Integer) Number of networks to support |
| ovs_vsctl_timeout = 120 | (Integer) Amount of time, in seconds, that ovs_vsctl should wait for a response from the database. 0 is to wait forever. |
| public_interface = eth0 | (String) Interface for public IP addresses |
| routing_source_ip = $my_ip | (String) Public IP of network host |
| security_group_api = nova | (String) DEPRECATED: The full class name of the security API class |
| send_arp_for_ha = False | (Boolean) Send gratuitous ARPs for HA setup |
| send_arp_for_ha_count = 3 | (Integer) Send this many gratuitous ARPs for HA setup |
| share_dhcp_address = False | (Boolean) DEPRECATED: THIS VALUE SHOULD BE SET WHEN CREATING THE NETWORK. If True in multi_host mode, all compute hosts share the same dhcp address. The same IP address used for DHCP will be added on each nova-network node which is only visible to the vms on the same host. |
| teardown_unused_network_gateway = False | (Boolean) If True, unused gateway devices (VLAN and bridge) are deleted in VLAN network mode with multi hosted networks |
| update_dns_entries = False | (Boolean) If True, when a DNS entry must be updated, it sends a fanout cast to all network hosts to update their DNS entries in multi host mode |
| use_network_dns_servers = False | (Boolean) If set, uses the dns1 and dns2 from the network ref. as dns servers. |
| use_neutron = False | (Boolean) Whether to use Neutron or Nova Network as the back end for networking. Defaults to False (indicating Nova network). Set to True to use neutron. |
| use_neutron_default_nets = False | (String) Control for checking for default networks |
| use_single_default_gateway = False | (Boolean) Use single default gateway. Only first nic of vm will get default gateway from dhcp server |
| vlan_interface = None | (String) VLANs will bridge into this interface if set |
| vlan_start = 100 | (Integer) First VLAN for private networks |
| [libvirt] | |
| remote_filesystem_transport = ssh | (String) Use ssh or rsync transport for creating, copying, removing files on the remote host. |
| [vmware] | |
| vlan_interface = vmnic0 | (String) Physical ethernet adapter name for vlan networking |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| neutron_default_tenant_id = default | (String) Default tenant id when creating neutron networks |
| [neutron] | |
| auth_section = None | (Unknown) Config Section from which to load plugin specific options |
| auth_type = None | (Unknown) Authentication type to load |
| cafile = None | (String) PEM encoded Certificate Authority to use when verifying HTTPs connections. |
| certfile = None | (String) PEM encoded client certificate cert file |
| extension_sync_interval = 600 | (Integer) Number of seconds before querying neutron for extensions |
| insecure = False | (Boolean) Verify HTTPS connections. |
| keyfile = None | (String) PEM encoded client certificate key file |
| metadata_proxy_shared_secret = | (String) Shared secret to validate proxies Neutron metadata requests |
| ovs_bridge = br-int | (String) Default OVS bridge name to use if not specified by Neutron |
| region_name = None | (String) Region name for connecting to neutron in admin context |
| service_metadata_proxy = False | (Boolean) Set flag to indicate Neutron will proxy metadata requests and resolve instance ids. |
| timeout = None | (Integer) Timeout value for http requests |
| url = http://127.0.0.1:9696 | (String) URL for connecting to neutron |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| pci_alias = [] | (Multi-valued) An alias for a PCI passthrough device requirement. This allows users to specify the alias in the extra_spec for a flavor, without needing to repeat all the PCI property requirements. Possible Values: * A list of JSON values which describe the aliases. For example: pci_alias = { “name”: “QuickAssist”, “product_id”: “0443”, “vendor_id”: “8086”, “device_type”: “type-PCI” } defines an alias for the Intel QuickAssist card. (multi valued). Valid key values are : * “name” * “product_id” * “vendor_id” * “device_type” Services which consume this: * nova-compute Related options: * None |
| pci_passthrough_whitelist = [] | (Multi-valued) White list of PCI devices available to VMs. Possible values: * A JSON dictionary which describe a whitelisted PCI device. It should take the following format: [“device_id”: “<id>”,] [“product_id”: “<id>”,] [“address”: “[[[[<domain>]:]<bus>]:][<slot>][.[<function>]]” | “devname”: “PCI Device Name”,] {“tag”: “<tag_value>”,} where ‘[‘ indicates zero or one occurrences, ‘{‘ indicates zero or multiple occurrences, and ‘|’ mutually exclusive options. Note that any missing fields are automatically wildcarded. Valid examples are: pci_passthrough_whitelist = {“devname”:”eth0”, “physical_network”:”physnet”} pci_passthrough_whitelist = {“address”:”:0a:00.“} pci_passthrough_whitelist = {“address”:”:0a:00.”, “physical_network”:”physnet1”} pci_passthrough_whitelist = {“vendor_id”:”1137”, “product_id”:”0071”} pci_passthrough_whitelist = {“vendor_id”:”1137”, “product_id”:”0071”, “address”: “0000:0a:00.1”, “physical_network”:”physnet1”} The following are invalid, as they specify mutually exclusive options: pci_passthrough_whitelist = {“devname”:”eth0”, “physical_network”:”physnet”, “address”:”:0a:00.“} * A JSON list of JSON dictionaries corresponding to the above format. For example: pci_passthrough_whitelist = [{“product_id”:”0001”, “vendor_id”:”8086”}, {“product_id”:”0002”, “vendor_id”:”8086”}] Services which consume this: * nova-compute Related options: * None |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| periodic_enable = True | (Boolean) Enable periodic tasks |
| periodic_fuzzy_delay = 60 | (Integer) Range of seconds to randomly delay when starting the periodic task scheduler to reduce stampeding. (Disable by setting to 0) |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| allow_instance_snapshots = True | (Boolean) Permit instance snapshot operations. |
| allow_resize_to_same_host = False | (Boolean) Allow destination machine to match source for resize. Useful when testing in single-host environments. |
| max_age = 0 | (Integer) Number of seconds between subsequent usage refreshes. This defaults to 0(off) to avoid additional load but it is useful to turn on to help keep quota usage up to date and reduce the impact of out of sync usage issues. Note that quotas are not updated on a periodic task, they will update on a new reservation if max_age has passed since the last reservation |
| max_local_block_devices = 3 | (Integer) Maximum number of devices that will result in a local image being created on the hypervisor node. A negative number means unlimited. Setting max_local_block_devices to 0 means that any request that attempts to create a local disk will fail. This option is meant to limit the number of local discs (so root local disc that is the result of –image being used, and any other ephemeral and swap disks). 0 does not mean that images will be automatically converted to volumes and boot instances from volumes - it just means that all requests that attempt to create a local disk will fail. |
| osapi_compute_unique_server_name_scope = | (String) When set, compute API will consider duplicate hostnames invalid within the specified scope, regardless of case. Should be empty, “project” or “global”. |
| osapi_max_limit = 1000 | (Integer) The maximum number of items returned in a single response from a collection resource |
| password_length = 12 | (Integer) Length of generated instance admin passwords |
| reservation_expire = 86400 | (Integer) Number of seconds until a reservation expires |
| resize_fs_using_block_device = False | (Boolean) Attempt to resize the filesystem by accessing the image over a block device. This is done by the host and may not be necessary if the image contains a recent version of cloud-init. Possible mechanisms require the nbd driver (for qcow and raw), or loop (for raw). |
| until_refresh = 0 | (Integer) Count of reservations until usage is refreshed. This defaults to 0(off) to avoid additional load but it is useful to turn on to help keep quota usage up to date and reduce the impact of out of sync usage issues. |
| [oslo_policy] | |
| policy_default_rule = default | (String) Default rule. Enforced when a requested rule is not found. |
| policy_dirs = ['policy.d'] | (Multi-valued) Directories where policy configuration files are stored. They can be relative to any directory in the search path defined by the config_dir option, or absolute paths. The file defined by policy_file must exist for these directories to be searched. Missing or empty directories are ignored. |
| policy_file = policy.json | (String) The JSON file that defines policies. |
| Configuration option = Default value | Description |
|---|---|
| [libvirt] | |
| quobyte_client_cfg = None | (String) Path to a Quobyte Client configuration file. |
| quobyte_mount_point_base = $state_path/mnt | (String) Directory where the Quobyte volume is mounted on the compute node |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| bandwidth_poll_interval = 600 | (Integer) Interval to pull network bandwidth usage info. Not supported on all hypervisors. Set to -1 to disable. Setting this to 0 will run at the default rate. |
| enable_network_quota = False | (Boolean) Enables or disables quota checking for tenant networks |
| quota_cores = 20 | (Integer) Number of instance cores allowed per project |
| quota_driver = nova.quota.DbQuotaDriver | (String) Default driver to use for quota checks |
| quota_fixed_ips = -1 | (Integer) Number of fixed IPs allowed per project (this should be at least the number of instances allowed) |
| quota_floating_ips = 10 | (Integer) Number of floating IPs allowed per project |
| quota_injected_file_content_bytes = 10240 | (Integer) Number of bytes allowed per injected file |
| quota_injected_file_path_length = 255 | (Integer) Length of injected file path |
| quota_injected_files = 5 | (Integer) Number of injected files allowed |
| quota_instances = 10 | (Integer) Number of instances allowed per project |
| quota_key_pairs = 100 | (Integer) Number of key pairs per user |
| quota_metadata_items = 128 | (Integer) Number of metadata items allowed per instance |
| quota_networks = 3 | (Integer) Number of private networks allowed per project |
| quota_ram = 51200 | (Integer) Megabytes of instance RAM allowed per project |
| quota_security_group_rules = 20 | (Integer) Number of security rules per security group |
| quota_security_groups = 10 | (Integer) Number of security groups per project |
| quota_server_group_members = 10 | (Integer) Number of servers per server group |
| quota_server_groups = 10 | (Integer) Number of server groups per project |
| [cells] | |
| bandwidth_update_interval = 600 | (Integer) Bandwidth update interval Seconds between bandwidth usage cache updates for cells. Possible values: * Time in seconds. Services which consume this: * nova-compute Related options: * None |
| Configuration option = Default value | Description |
|---|---|
| [rdp] | |
| enabled = False | (Boolean) Enable RDP related features |
| html5_proxy_base_url = http://127.0.0.1:6083/ | (String) Location of RDP html5 console proxy, in the form “http://127.0.0.1:6083/“ |
| Configuration option = Default value | Description |
|---|---|
| [matchmaker_redis] | |
| check_timeout = 20000 | (Integer) Time in ms to wait before the transaction is killed. |
| host = 127.0.0.1 | (String) Host to locate redis. |
| password = | (String) Password for Redis server (optional). |
| port = 6379 | (Port number) Use this port to connect to redis host. |
| sentinel_group_name = oslo-messaging-zeromq | (String) Redis replica set name. |
| sentinel_hosts = | (List) List of Redis Sentinel hosts (fault tolerance mode) e.g. [host:port, host1:port ... ] |
| socket_timeout = 1000 | (Integer) Timeout in ms on blocking socket operations |
| wait_timeout = 500 | (Integer) Time in ms to wait between connection attempts. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| image_decryption_dir = /tmp | (String) Parent directory for tempdir used for image decryption |
| s3_access_key = notchecked | (String) Access key to use for S3 server for images |
| s3_affix_tenant = False | (Boolean) Whether to affix the tenant id to the access key when downloading from S3 |
| s3_host = $my_ip | (String) Hostname or IP for OpenStack to use when accessing the S3 api |
| s3_port = 3333 | (Integer) Port used when accessing the S3 api |
| s3_secret_key = notchecked | (String) Secret key to use for S3 server for images |
| s3_use_ssl = False | (Boolean) Whether to use SSL when talking to S3 |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| aggregate_image_properties_isolation_namespace = None | (String) Images and hosts can be configured so that certain images can only be scheduled to hosts in a particular aggregate. This is done with metadata values set on the host aggregate that are identified by beginning with the value of this option. If the host is part of an aggregate with such a metadata key, the image in the request spec must have the value of that metadata in its properties in order for the scheduler to consider the host as acceptable. Valid values are strings. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘aggregate_image_properties_isolation’ filter is enabled. * Services that use this: nova-scheduler * Related options: aggregate_image_properties_isolation_separator |
| aggregate_image_properties_isolation_separator = . | (String) When using the aggregate_image_properties_isolation filter, the relevant metadata keys are prefixed with the namespace defined in the aggregate_image_properties_isolation_namespace configuration option plus a separator. This option defines the separator to be used. It defaults to a period (‘.’). Valid values are strings. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘aggregate_image_properties_isolation’ filter is enabled. * Services that use this: nova-scheduler * Related options: aggregate_image_properties_isolation_namespace |
| baremetal_scheduler_default_filters = RetryFilter, AvailabilityZoneFilter, ComputeFilter, ComputeCapabilitiesFilter, ImagePropertiesFilter, ExactRamFilter, ExactDiskFilter, ExactCoreFilter | (List) This option specifies the filters used for filtering baremetal hosts. The value should be a list of strings, with each string being the name of a filter class to be used. When used, they will be applied in order, so place your most restrictive filters first to make the filtering process more efficient. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: If the ‘scheduler_use_baremetal_filters’ option is False, this option has no effect. |
| cpu_allocation_ratio = 0.0 | (Floating point) Virtual CPU to physical CPU allocation ratio which affects all CPU filters. This configuration specifies a global ratio for CoreFilter. For AggregateCoreFilter, it will fall back to this configuration value if no per-aggregate setting found. NOTE: This can be set per-compute, or if set to 0.0, the value set on the scheduler node(s) will be used and defaulted to 16.0 |
| disk_allocation_ratio = 0.0 | (Floating point) This is the virtual disk to physical disk allocation ratio used by the disk_filter.py script to determine if a host has sufficient disk space to fit a requested instance. A ratio greater than 1.0 will result in over-subscription of the available physical disk, which can be useful for more efficiently packing instances created with images that do not use the entire virtual disk,such as sparse or compressed images. It can be set to a value between 0.0 and 1.0 in order to preserve a percentage of the disk for uses other than instances.NOTE: This can be set per-compute, or if set to 0.0, the value set on the scheduler node(s) will be used and defaulted to 1.0 |
| disk_weight_multiplier = 1.0 | (Floating point) Multiplier used for weighing free disk space. Negative numbers mean to stack vs spread. |
| io_ops_weight_multiplier = -1.0 | (Floating point) This option determines how hosts with differing workloads are weighed. Negative values, such as the default, will result in the scheduler preferring hosts with lighter workloads whereas positive values will prefer hosts with heavier workloads. Another way to look at it is that positive values for this option will tend to schedule instances onto hosts that are already busy, while negative values will tend to distribute the workload across more hosts. The absolute value, whether positive or negative, controls how strong the io_ops weigher is relative to other weighers. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘io_ops’ weigher is enabled. Valid values are numeric, either integer or float. * Services that use this: nova-scheduler * Related options: None |
| isolated_hosts = | (List) If there is a need to restrict some images to only run on certain designated hosts, list those host names here. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘IsolatedHostsFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: scheduler/isolated_images scheduler/restrict_isolated_hosts_to_isolated_images |
| isolated_images = | (List) If there is a need to restrict some images to only run on certain designated hosts, list those image UUIDs here. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘IsolatedHostsFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: scheduler/isolated_hosts scheduler/restrict_isolated_hosts_to_isolated_images |
| max_instances_per_host = 50 | (Integer) If you need to limit the number of instances on any given host, set this option to the maximum number of instances you want to allow. The num_instances_filter will reject any host that has at least as many instances as this option’s value. Valid values are positive integers; setting it to zero will cause all hosts to be rejected if the num_instances_filter is active. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘num_instances_filter’ filter is enabled. * Services that use this: nova-scheduler * Related options: None |
| max_io_ops_per_host = 8 | (Integer) This setting caps the number of instances on a host that can be actively performing IO (in a build, resize, snapshot, migrate, rescue, or unshelve task state) before that host becomes ineligible to build new instances. Valid values are positive integers: 1 or greater. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘io_ops_filter’ filter is enabled. * Services that use this: nova-scheduler * Related options: None |
| ram_allocation_ratio = 0.0 | (Floating point) Virtual ram to physical ram allocation ratio which affects all ram filters. This configuration specifies a global ratio for RamFilter. For AggregateRamFilter, it will fall back to this configuration value if no per-aggregate setting found. NOTE: This can be set per-compute, or if set to 0.0, the value set on the scheduler node(s) will be used and defaulted to 1.5 |
| ram_weight_multiplier = 1.0 | (Floating point) This option determines how hosts with more or less available RAM are weighed. A positive value will result in the scheduler preferring hosts with more available RAM, and a negative number will result in the scheduler preferring hosts with less available RAM. Another way to look at it is that positive values for this option will tend to spread instances across many hosts, while negative values will tend to fill up (stack) hosts as much as possible before scheduling to a less-used host. The absolute value, whether positive or negative, controls how strong the RAM weigher is relative to other weighers. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘ram’ weigher is enabled. Valid values are numeric, either integer or float. * Services that use this: nova-scheduler * Related options: None |
| reserved_host_disk_mb = 0 | (Integer) Amount of disk in MB to reserve for the host |
| reserved_host_memory_mb = 512 | (Integer) Amount of memory in MB to reserve for the host |
| restrict_isolated_hosts_to_isolated_images = True | (Boolean) This setting determines if the scheduler’s isolated_hosts filter will allow non-isolated images on a host designated as an isolated host. When set to True (the default), non-isolated images will not be allowed to be built on isolated hosts. When False, non-isolated images can be built on both isolated and non-isolated hosts alike. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘IsolatedHostsFilter’ filter is enabled. Even then, this option doesn’t affect the behavior of requests for isolated images, which will always be restricted to isolated hosts. * Services that use this: nova-scheduler * Related options: scheduler/isolated_images scheduler/isolated_hosts |
| scheduler_available_filters = ['nova.scheduler.filters.all_filters'] | (Multi-valued) This is an unordered list of the filter classes the Nova scheduler may apply. Only the filters specified in the ‘scheduler_default_filters’ option will be used, but any filter appearing in that option must also be included in this list. By default, this is set to all filters that are included with Nova. If you wish to change this, replace this with a list of strings, where each element is the path to a filter. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: scheduler_default_filters |
| scheduler_default_filters = RetryFilter, AvailabilityZoneFilter, RamFilter, DiskFilter, ComputeFilter, ComputeCapabilitiesFilter, ImagePropertiesFilter, ServerGroupAntiAffinityFilter, ServerGroupAffinityFilter | (List) This option is the list of filter class names that will be used for filtering hosts. The use of ‘default’ in the name of this option implies that other filters may sometimes be used, but that is not the case. These filters will be applied in the order they are listed, so place your most restrictive filters first to make the filtering process more efficient. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: All of the filters in this option must be present in the ‘scheduler_available_filters’ option, or a SchedulerHostFilterNotFound exception will be raised. |
| scheduler_driver = filter_scheduler | (String) The class of the driver used by the scheduler. This should be chosen from one of the entrypoints under the namespace ‘nova.scheduler.driver’ of file ‘setup.cfg’. If nothing is specified in this option, the ‘filter_scheduler’ is used. This option also supports deprecated full Python path to the class to be used. For example, “nova.scheduler.filter_scheduler.FilterScheduler”. But note: this support will be dropped in the N Release. Other options are: * ‘caching_scheduler’ which aggressively caches the system state for better individual scheduler performance at the risk of more retries when running multiple schedulers. * ‘chance_scheduler’ which simply picks a host at random. * ‘fake_scheduler’ which is used for testing. * Services that use this: nova-scheduler * Related options: None |
| scheduler_driver_task_period = 60 | (Integer) This value controls how often (in seconds) to run periodic tasks in the scheduler. The specific tasks that are run for each period are determined by the particular scheduler being used. If this is larger than the nova-service ‘service_down_time’ setting, Nova may report the scheduler service as down. This is because the scheduler driver is responsible for sending a heartbeat and it will only do that as often as this option allows. As each scheduler can work a little differently than the others, be sure to test this with your selected scheduler. * Services that use this: nova-scheduler * Related options: nova-service service_down_time |
| scheduler_host_manager = host_manager | (String) The scheduler host manager to use, which manages the in-memory picture of the hosts that the scheduler uses. The option value should be chosen from one of the entrypoints under the namespace ‘nova.scheduler.host_manager’ of file ‘setup.cfg’. For example, ‘host_manager’ is the default setting. Aside from the default, the only other option as of the Mitaka release is ‘ironic_host_manager’, which should be used if you’re using Ironic to provision bare-metal instances. This option also supports a full class path style, for example “nova.scheduler.host_manager.HostManager”, but note this support is deprecated and will be dropped in the N release. * Services that use this: nova-scheduler * Related options: None |
| scheduler_host_subset_size = 1 | (Integer) New instances will be scheduled on a host chosen randomly from a subset of the N best hosts, where N is the value set by this option. Valid values are 1 or greater. Any value less than one will be treated as 1. Setting this to a value greater than 1 will reduce the chance that multiple scheduler processes handling similar requests will select the same host, creating a potential race condition. By selecting a host randomly from the N hosts that best fit the request, the chance of a conflict is reduced. However, the higher you set this value, the less optimal the chosen host may be for a given request. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: None |
| scheduler_instance_sync_interval = 120 | (Integer) Waiting time interval (seconds) between sending the scheduler a list of current instance UUIDs to verify that its view of instances is in sync with nova. If the CONF option scheduler_tracks_instance_changes is False, changing this option will have no effect. |
| scheduler_json_config_location = | (String) The absolute path to the scheduler configuration JSON file, if any. This file location is monitored by the scheduler for changes and reloads it if needed. It is converted from JSON to a Python data structure, and passed into the filtering and weighing functions of the scheduler, which can use it for dynamic configuration. * Services that use this: nova-scheduler * Related options: None |
| scheduler_manager = nova.scheduler.manager.SchedulerManager | (String) DEPRECATED: Full class name for the Manager for scheduler |
| scheduler_max_attempts = 3 | (Integer) This is the maximum number of attempts that will be made to schedule an instance before it is assumed that the failures aren’t due to normal occasional race conflicts, but rather some other problem. When this is reached a MaxRetriesExceeded exception is raised, and the instance is set to an error state. Valid values are positive integers (1 or greater). * Services that use this: nova-scheduler * Related options: None |
| scheduler_topic = scheduler | (String) This is the message queue topic that the scheduler ‘listens’ on. It is used when the scheduler service is started up to configure the queue, and whenever an RPC call to the scheduler is made. There is almost never any reason to ever change this value. * Services that use this: nova-scheduler * Related options: None |
| scheduler_tracks_instance_changes = True | (Boolean) The scheduler may need information about the instances on a host in order to evaluate its filters and weighers. The most common need for this information is for the (anti-)affinity filters, which need to choose a host based on the instances already running on a host. If the configured filters and weighers do not need this information, disabling this option will improve performance. It may also be disabled when the tracking overhead proves too heavy, although this will cause classes requiring host usage data to query the database on each request instead. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: None |
| scheduler_use_baremetal_filters = False | (Boolean) Set this to True to tell the nova scheduler that it should use the filters specified in the ‘baremetal_scheduler_default_filters’ option. If you are not scheduling baremetal nodes, leave this at the default setting of False. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: If this option is set to True, then the filters specified in the ‘baremetal_scheduler_default_filters’ are used instead of the filters specified in ‘scheduler_default_filters’. |
| scheduler_weight_classes = nova.scheduler.weights.all_weighers | (List) This is a list of weigher class names. Only hosts which pass the filters are weighed. The weight for any host starts at 0, and the weighers order these hosts by adding to or subtracting from the weight assigned by the previous weigher. Weights may become negative. An instance will be scheduled to one of the N most-weighted hosts, where N is ‘scheduler_host_subset_size’. By default, this is set to all weighers that are included with Nova. If you wish to change this, replace this with a list of strings, where each element is the path to a weigher. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: None |
| soft_affinity_weight_multiplier = 1.0 | (Floating point) Multiplier used for weighing hosts for group soft-affinity. Only a positive value is meaningful. Negative means that the behavior will change to the opposite, which is soft-anti-affinity. |
| soft_anti_affinity_weight_multiplier = 1.0 | (Floating point) Multiplier used for weighing hosts for group soft-anti-affinity. Only a positive value is meaningful. Negative means that the behavior will change to the opposite, which is soft-affinity. |
| [cells] | |
| ram_weight_multiplier = 10.0 | (Floating point) Ram weight multiplier Multiplier used for weighing ram. Negative numbers indicate that Compute should stack VMs on one host instead of spreading out new VMs to more hosts in the cell. Possible values: * Numeric multiplier Services which consume this: * nova-cells Related options: * None |
| scheduler_filter_classes = nova.cells.filters.all_filters | (List) Scheduler filter classes Filter classes the cells scheduler should use. An entry of “nova.cells.filters.all_filters” maps to all cells filters included with nova. As of the Mitaka release the following filter classes are available: Different cell filter: A scheduler hint of ‘different_cell’ with a value of a full cell name may be specified to route a build away from a particular cell. Image properties filter: Image metadata named ‘hypervisor_version_requires’ with a version specification may be specified to ensure the build goes to a cell which has hypervisors of the required version. If either the version requirement on the image or the hypervisor capability of the cell is not present, this filter returns without filtering out the cells. Target cell filter: A scheduler hint of ‘target_cell’ with a value of a full cell name may be specified to route a build to a particular cell. No error handling is done as there’s no way to know whether the full path is a valid. As an admin user, you can also add a filter that directs builds to a particular cell. Possible values: * ‘nova.cells.filters.all_filters’ is the default option * Otherwise it should be the full Python path to the class to be used Services which consume this: * nova-cells Related options: * None |
| scheduler_retries = 10 | (Integer) Scheduler retries How many retries when no cells are available. Specifies how many times the scheduler tries to launch a new instance when no cells are available. Possible values: * Positive integer value Services which consume this: * nova-cells Related options: * This value is used with the scheduler_retry_delay value while retrying to find a suitable cell. |
| scheduler_retry_delay = 2 | (Integer) Scheduler retry delay Specifies the delay (in seconds) between scheduling retries when no cell can be found to place the new instance on. When the instance could not be scheduled to a cell after scheduler_retries in combination with scheduler_retry_delay, then the scheduling of the instance failed. Possible values: * Time in seconds. Services which consume this: * nova-cells Related options: * This value is used with the scheduler_retries value while retrying to find a suitable cell. |
| scheduler_weight_classes = nova.cells.weights.all_weighers | (List) Scheduler weight classes Weigher classes the cells scheduler should use. An entry of “nova.cells.weights.all_weighers” maps to all cell weighers included with nova. As of the Mitaka release the following weight classes are available: mute_child: Downgrades the likelihood of child cells being chosen for scheduling requests, which haven’t sent capacity or capability updates in a while. Options include mute_weight_multiplier (multiplier for mute children; value should be negative). ram_by_instance_type: Select cells with the most RAM capacity for the instance type being requested. Because higher weights win, Compute returns the number of available units for the instance type requested. The ram_weight_multiplier option defaults to 10.0 that adds to the weight by a factor of 10. Use a negative number to stack VMs on one host instead of spreading out new VMs to more hosts in the cell. weight_offset: Allows modifying the database to weight a particular cell. The highest weight will be the first cell to be scheduled for launching an instance. When the weight_offset of a cell is set to 0, it is unlikely to be picked but it could be picked if other cells have a lower weight, like if they’re full. And when the weight_offset is set to a very high value (for example, ‘999999999999999’), it is likely to be picked if another cell do not have a higher weight. Possible values: * ‘nova.cells.weights.all_weighers’ is the default option * Otherwise it should be the full Python path to the class to be used Services which consume this: * nova-cells Related options: * None |
| [metrics] | |
| required = True | (Boolean) This setting determines how any unavailable metrics are treated. If this option is set to True, any hosts for which a metric is unavailable will raise an exception, so it is recommended to also use the MetricFilter to filter out those hosts before weighing. When this option is False, any metric being unavailable for a host will set the host weight to ‘weight_of_unavailable’. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: weight_of_unavailable |
| weight_multiplier = 1.0 | (Floating point) When using metrics to weight the suitability of a host, you can use this option to change how the calculated weight influences the weight assigned to a host as follows: * Greater than 1.0: increases the effect of the metric on overall weight. * Equal to 1.0: No change to the calculated weight. * Less than 1.0, greater than 0: reduces the effect of the metric on overall weight. * 0: The metric value is ignored, and the value of the ‘weight_of_unavailable’ option is returned instead. * Greater than -1.0, less than 0: the effect is reduced and reversed. * -1.0: the effect is reversed * Less than -1.0: the effect is increased proportionally and reversed. Valid values are numeric, either integer or float. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: weight_of_unavailable |
| weight_of_unavailable = -10000.0 | (Floating point) When any of the following conditions are met, this value will be used in place of any actual metric value: * One of the metrics named in ‘weight_setting’ is not available for a host, and the value of ‘required’ is False. * The ratio specified for a metric in ‘weight_setting’ is 0. * The ‘weight_multiplier’ option is set to 0. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: weight_setting required weight_multiplier |
| weight_setting = | (List) This setting specifies the metrics to be weighed and the relative ratios for each metric. This should be a single string value, consisting of a series of one or more ‘name=ratio’ pairs, separated by commas, where ‘name’ is the name of the metric to be weighed, and ‘ratio’ is the relative weight for that metric. Note that if the ratio is set to 0, the metric value is ignored, and instead the weight will be set to the value of the ‘weight_of_unavailable’ option. As an example, let’s consider the case where this option is set to: name1=1.0, name2=-1.3 The final weight will be: (name1.value * 1.0) + (name2.value * -1.3) This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. * Services that use this: nova-scheduler * Related options: weight_of_unavailable |
| Configuration option = Default value | Description |
|---|---|
| [serial_console] | |
| base_url = ws://127.0.0.1:6083/ | (String) The URL an end user would use to connect to the nova-serialproxy service. The nova-serialproxy service is called with this token enriched URL and establishes the connection to the proper instance. Possible values: * <scheme><IP-address><port-number> Services which consume this: * nova-compute Interdependencies to other options: * The IP address must be identical to the address to which the nova-serialproxy service is listening (see option serialproxy_host in this section). * The port must be the same as in the option serialproxy_port of this section. * If you choose to use a secured websocket connection, then start this option with wss:// instead of the unsecured ws://. The options cert and key in the [DEFAULT] section have to be set for that. |
| enabled = False | (Boolean) Enable the serial console feature. In order to use this feature, the service nova-serialproxy needs to run. This service is typically executed on the controller node. Possible values: * True: Enables the feature * False: Disables the feature Services which consume this: * nova-compute Interdependencies to other options: * None |
| listen = 127.0.0.1 | (String) DEPRECATED: this option has no effect anymore. Please use “proxyclient_address” instead. This option is deprecated and will be removed in future releases. |
| port_range = 10000:20000 | (String) A range of TCP ports a guest can use for its backend. Each instance which gets created will use one port out of this range. If the range is not big enough to provide another port for an new instance, this instance won’t get launched. Possible values: Each string which passes the regex \d+:\d+ For example 10000:20000. Be sure that the first port number is lower than the second port number. Services which consume this: * nova-compute Interdependencies to other options: * None |
| proxyclient_address = 127.0.0.1 | (String) The IP address to which proxy clients (like nova-serialproxy) should connect to get the serial console of an instance. This is typically the IP address of the host of a nova-compute service. Possible values: * An IP address Services which consume this: * nova-compute Interdependencies to other options: * None |
| serialproxy_host = 0.0.0.0 | (String) The IP address which is used by the nova-serialproxy service to listen for incoming requests. The nova-serialproxy service listens on this IP address for incoming connection requests to instances which expose serial console. Possible values: * An IP address Services which consume this: * nova-serialproxy Interdependencies to other options: * Ensure that this is the same IP address which is defined in the option base_url of this section or use 0.0.0.0 to listen on all addresses. |
| serialproxy_port = 6083 | (Integer) The port number which is used by the nova-serialproxy service to listen for incoming requests. The nova-serialproxy service listens on this port number for incoming connection requests to instances which expose serial console. Possible values: * A port number Services which consume this: * nova-serialproxy Interdependencies to other options: * Ensure that this is the same port number which is defined in the option base_url of this section. |
| Configuration option = Default value | Description |
|---|---|
| [spice] | |
| agent_enabled = True | (Boolean) Enable spice guest agent support |
| enabled = False | (Boolean) Enable spice related features |
| html5proxy_base_url = http://127.0.0.1:6082/spice_auto.html | (String) Location of spice HTML5 console proxy, in the form “http://127.0.0.1:6082/spice_auto.html“ |
| html5proxy_host = 0.0.0.0 | (String) Host on which to listen for incoming requests |
| html5proxy_port = 6082 | (Integer) Port on which to listen for incoming requests |
| keymap = en-us | (String) Keymap for spice |
| server_listen = 127.0.0.1 | (String) IP address on which instance spice server should listen |
| server_proxyclient_address = 127.0.0.1 | (String) The address to which proxy clients (like nova-spicehtml5proxy) should connect |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| fake_call = False | (Boolean) If True, skip using the queue and make local calls |
| fake_network = False | (Boolean) If passed, use fake network devices and addresses |
| monkey_patch = False | (Boolean) Whether to apply monkey patching |
| monkey_patch_modules = nova.compute.api:nova.notifications.notify_decorator | (List) List of modules/decorators to monkey patch |
| Configuration option = Default value | Description |
|---|---|
| [trusted_computing] | |
| attestation_api_url = /OpenAttestationWebServices/V1.0 | (String) The URL on the attestation server to use. See the attestation_server help text for more information about host verification. This value must be just that path portion of the full URL, as it will be joined to the host specified in the attestation_server option. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_server_ca_file attestation_port attestation_auth_blob attestation_auth_timeout attestation_insecure_ssl |
| attestation_auth_blob = None | (String) Attestation servers require a specific blob that is used to authenticate. The content and format of the blob are determined by the particular attestation server being used. There is no default value; you must supply the value as specified by your attestation service. See the attestation_server help text for more information about host verification. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_server_ca_file attestation_port attestation_api_url attestation_auth_timeout attestation_insecure_ssl |
| attestation_auth_timeout = 60 | (Integer) This value controls how long a successful attestation is cached. Once this period has elapsed, a new attestation request will be made. See the attestation_server help text for more information about host verification. The value is in seconds. Valid values must be positive integers for any caching; setting this to zero or a negative value will result in calls to the attestation_server for every request, which may impact performance. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_server_ca_file attestation_port attestation_api_url attestation_auth_blob attestation_insecure_ssl |
| attestation_insecure_ssl = False | (Boolean) When set to True, the SSL certificate verification is skipped for the attestation service. See the attestation_server help text for more information about host verification. Valid values are True or False. The default is False. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_server_ca_file attestation_port attestation_api_url attestation_auth_blob attestation_auth_timeout |
| attestation_port = 8443 | (String) The port to use when connecting to the attestation server. See the attestation_server help text for more information about host verification. Valid values are strings, not integers, but must be digits only. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_server_ca_file attestation_api_url attestation_auth_blob attestation_auth_timeout attestation_insecure_ssl |
| attestation_server = None | (String) The host to use as the attestation server. Cloud computing pools can involve thousands of compute nodes located at different geographical locations, making it difficult for cloud providers to identify a node’s trustworthiness. When using the Trusted filter, users can request that their VMs only be placed on nodes that have been verified by the attestation server specified in this option. The value is a string, and can be either an IP address or FQDN. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server_ca_file attestation_port attestation_api_url attestation_auth_blob attestation_auth_timeout attestation_insecure_ssl |
| attestation_server_ca_file = None | (String) The absolute path to the certificate to use for authentication when connecting to the attestation server. See the attestation_server help text for more information about host verification. The value is a string, and must point to a file that is readable by the scheduler. This option is only used by the FilterScheduler and its subclasses; if you use a different scheduler, this option has no effect. Also note that this setting only affects scheduling if the ‘TrustedFilter’ filter is enabled. * Services that use this: nova-scheduler * Related options: attestation_server attestation_port attestation_api_url attestation_auth_blob attestation_auth_timeout attestation_insecure_ssl |
| Configuration option = Default value | Description |
|---|---|
| [cells] | |
| scheduler = nova.cells.scheduler.CellsScheduler | (String) Cells scheduler The class of the driver used by the cells scheduler. This should be the full Python path to the class to be used. If nothing is specified in this option, the CellsScheduler is used. Possible values: * ‘nova.cells.scheduler.CellsScheduler’ is the default option * Otherwise it should be the full Python path to the class to be used Services which consume this: * nova-cells Related options: * None |
| [upgrade_levels] | |
| cells = None | (String) Cells version Cells client-side RPC API version. Use this option to set a version cap for messages sent to local cells services. Possible values: * None: This is the default value. * grizzly: message version 1.6. * havana: message version 1.24. * icehouse: message version 1.27. * juno: message version 1.29. * kilo: message version 1.34. * liberty: message version 1.37. Services which consume this: * nova-cells Related options: * None |
| cert = None | (String) Specifies the maximum version for messages sent from cert services. This should be the minimum value that is supported by all of the deployed cert services. Possible values: Any valid OpenStack release name, in lower case, such as ‘mitaka’ or ‘liberty’. Alternatively, it can be any string representing a version number in the format ‘N.N’; for example, possible values might be ‘1.12’ or ‘2.0’. * Services which consume this: nova-cert * Related options: None |
| compute = None | (String) Set a version cap for messages sent to compute services. Set this option to “auto” if you want to let the compute RPC module automatically determine what version to use based on the service versions in the deployment. Otherwise, you can set this to a specific version to pin this service to messages at a particular level. All services of a single type (i.e. compute) should be configured to use the same version, and it should be set to the minimum commonly-supported version of all those services in the deployment. |
| conductor = None | (String) Set a version cap for messages sent to conductor services |
| console = None | (String) Set a version cap for messages sent to console services |
| consoleauth = None | (String) Set a version cap for messages sent to consoleauth services |
| intercell = None | (String) Intercell version Intercell RPC API is the client side of the Cell<->Cell RPC API. Use this option to set a version cap for messages sent between cells services. Possible values: * None: This is the default value. * grizzly: message version 1.0. Services which consume this: * nova-cells Related options: * None |
| network = None | (String) Set a version cap for messages sent to network services |
| scheduler = None | (String) Sets a version cap (limit) for messages sent to scheduler services. In the situation where there were multiple scheduler services running, and they were not being upgraded together, you would set this to the lowest deployed version to guarantee that other services never send messages that any of your running schedulers cannot understand. This is rarely needed in practice as most deployments run a single scheduler. It exists mainly for design compatibility with the other services, such as compute, which are routinely upgraded in a rolling fashion. * Services that use this: nova-compute, nova-conductor * Related options: None |
| Configuration option = Default value | Description |
|---|---|
| [vArmour] | |
| director = localhost | (String) vArmour director ip |
| director_port = 443 | (String) vArmour director port |
| password = varmour | (String) vArmour director password |
| username = varmour | (String) vArmour director username |
| Configuration option = Default value | Description |
|---|---|
| [vmware] | |
| api_retry_count = 10 | (Integer) The number of times we retry on failures, e.g., socket error, etc. |
| ca_file = None | (String) Specify a CA bundle file to use in verifying the vCenter server certificate. |
| cache_prefix = None | (String) The prefix for where cached images are stored. This is NOT the full path - just a folder prefix. This should only be used when a datastore cache should be shared between compute nodes. Note: this should only be used when the compute nodes have a shared file system. |
| cluster_name = None | (String) Name of a VMware Cluster ComputeResource. |
| console_delay_seconds = None | (Integer) Set this value if affected by an increased network latency causing repeated characters when typing in a remote console. |
| datastore_regex = None | (String) Regex to match the name of a datastore. |
| host_ip = None | (String) Hostname or IP address for connection to VMware vCenter host. |
| host_password = None | (String) Password for connection to VMware vCenter host. |
| host_port = 443 | (Port number) Port for connection to VMware vCenter host. |
| host_username = None | (String) Username for connection to VMware vCenter host. |
| insecure = False | (Boolean) If true, the vCenter server certificate is not verified. If false, then the default CA truststore is used for verification. This option is ignored if “ca_file” is set. |
| integration_bridge = None | (String) This option should be configured only when using the NSX-MH Neutron plugin. This is the name of the integration bridge on the ESXi. This should not be set for any other Neutron plugin. Hence the default value is not set. |
| maximum_objects = 100 | (Integer) The maximum number of ObjectContent data objects that should be returned in a single result. A positive value will cause the operation to suspend the retrieval when the count of objects reaches the specified maximum. The server may still limit the count to something less than the configured value. Any remaining objects may be retrieved with additional requests. |
| pbm_default_policy = None | (String) The PBM default policy. If pbm_wsdl_location is set and there is no defined storage policy for the specific request then this policy will be used. |
| pbm_enabled = False | (Boolean) The PBM status. |
| pbm_wsdl_location = None | (String) PBM service WSDL file location URL. e.g. file:///opt/SDK/spbm/wsdl/pbmService.wsdl Not setting this will disable storage policy based placement of instances. |
| serial_port_proxy_uri = None | (String) Identifies a proxy service that provides network access to the serial_port_service_uri. This option is ignored if serial_port_service_uri is not specified. |
| serial_port_service_uri = None | (String) Identifies the remote system that serial port traffic will be sent to. If this is not set, no serial ports will be added to the created VMs. |
| task_poll_interval = 0.5 | (Floating point) The interval used for polling of remote tasks. |
| use_linked_clone = True | (Boolean) Whether to use linked clone |
| wsdl_location = None | (String) Optional VIM Service WSDL Location e.g http://<server>/vimService.wsdl. Optional over-ride to default location for bug work-arounds |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| daemon = False | (Boolean) Become a daemon (background process) |
| key = None | (String) SSL key file (if separate from cert) |
| record = False | (Boolean) Record sessions to FILE.[session_number] |
| source_is_ipv6 = False | (Boolean) Source is ipv6 |
| ssl_only = False | (Boolean) Disallow non-encrypted connections |
| web = /usr/share/spice-html5 | (String) Run webserver on same port. Serve files from DIR. |
| [vmware] | |
| vnc_port = 5900 | (Port number) VNC starting port |
| vnc_port_total = 10000 | (Integer) Total number of VNC ports |
| [vnc] | |
| enabled = True | (Boolean) Enable VNC related features. Guests will get created with graphical devices to support this. Clients (for example Horizon) can then establish a VNC connection to the guest. Possible values: * True: Enables the feature * False: Disables the feature Services which consume this: * nova-compute Related options: * None |
| keymap = en-us | (String) Keymap for VNC. The keyboard mapping (keymap) determines which keyboard layout a VNC session should use by default. Possible values: * A keyboard layout which is supported by the underlying hypervisor on this node. This is usually an ‘IETF language tag’ (for example ‘en-us’). If you use QEMU as hypervisor, you should find the list of supported keyboard layouts at /usr/share/qemu/keymaps. Services which consume this: * nova-compute Related options: * None |
| novncproxy_base_url = http://127.0.0.1:6080/vnc_auto.html | (String) Public address of noVNC VNC console proxy. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. noVNC provides VNC support through a websocket-based client. This option sets the public base URL to which client systems will connect. noVNC clients can use this address to connect to the noVNC instance and, by extension, the VNC sessions. Possible values: * A URL Services which consume this: * nova-compute Related options: * novncproxy_host * novncproxy_port |
| novncproxy_host = 0.0.0.0 | (String) IP address that the noVNC console proxy should bind to. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. noVNC provides VNC support through a websocket-based client. This option sets the private address to which the noVNC console proxy service should bind to. Possible values: * An IP address Services which consume this: * nova-compute Related options: * novncproxy_port * novncproxy_base_url |
| novncproxy_port = 6080 | (Integer) Port that the noVNC console proxy should bind to. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. noVNC provides VNC support through a websocket-based client. This option sets the private port to which the noVNC console proxy service should bind to. Possible values: * A port number Services which consume this: * nova-compute Related options: * novncproxy_host * novncproxy_base_url |
| vncserver_listen = 127.0.0.1 | (String) The IP address on which an instance should listen to for incoming VNC connection requests on this node. Possible values: * An IP address Services which consume this: * nova-compute Related options: * None |
| vncserver_proxyclient_address = 127.0.0.1 | (String) Private, internal address of VNC console proxy. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. This option sets the private address to which proxy clients, such as nova-xvpvncproxy, should connect to. Possible values: * An IP address Services which consume this: * nova-compute Related options: * None |
| xvpvncproxy_base_url = http://127.0.0.1:6081/console | (String) Public address of XVP VNC console proxy. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. Xen provides the Xenserver VNC Proxy, or XVP, as an alternative to the websocket-based noVNC proxy used by Libvirt. In contrast to noVNC, XVP clients are Java-based. This option sets the public base URL to which client systems will connect. XVP clients can use this address to connect to the XVP instance and, by extension, the VNC sessions. Possible values: * A URL Services which consume this: * nova-compute Related options: * xvpvncproxy_host * xvpvncproxy_port |
| xvpvncproxy_host = 0.0.0.0 | (String) IP address that the XVP VNC console proxy should bind to. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. Xen provides the Xenserver VNC Proxy, or XVP, as an alternative to the websocket-based noVNC proxy used by Libvirt. In contrast to noVNC, XVP clients are Java-based. This option sets the private address to which the XVP VNC console proxy service should bind to. Possible values: * An IP address Services which consume this: * nova-compute Related options: * xvpvncproxy_port * xvpvncproxy_base_url |
| xvpvncproxy_port = 6081 | (Integer) Port that the XVP VNC console proxy should bind to. The VNC proxy is an OpenStack component that enables compute service users to access their instances through VNC clients. Xen provides the Xenserver VNC Proxy, or XVP, as an alternative to the websocket-based noVNC proxy used by Libvirt. In contrast to noVNC, XVP clients are Java-based. This option sets the private port to which the XVP VNC console proxy service should bind to. Possible values: * A port number Services which consume this: * nova-compute Related options: * xvpvncproxy_host * xvpvncproxy_base_url |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| block_device_allocate_retries = 60 | (Integer) Number of times to retry block device allocation on failures. Starting with Liberty, Cinder can use image volume cache. This may help with block device allocation performance. Look at the cinder image_volume_cache_enabled configuration option. |
| block_device_allocate_retries_interval = 3 | (Integer) Waiting time interval (seconds) between block device allocation retries on failures |
| my_block_storage_ip = $my_ip | (String) Block storage IP address of this host |
| volume_api_class = nova.volume.cinder.API | (String) DEPRECATED: The full class name of the volume API class to use |
| volume_usage_poll_interval = 0 | (Integer) Interval in seconds for gathering volume usages |
| [cinder] | |
| cafile = None | (String) PEM encoded Certificate Authority to use when verifying HTTPs connections. |
| catalog_info = volumev2:cinderv2:publicURL | (String) Info to match when looking for cinder in the service catalog. Format is: separated values of the form: <service_type>:<service_name>:<endpoint_type> |
| certfile = None | (String) PEM encoded client certificate cert file |
| cross_az_attach = True | (Boolean) Allow attach between instance and volume in different availability zones. If False, volumes attached to an instance must be in the same availability zone in Cinder as the instance availability zone in Nova. This also means care should be taken when booting an instance from a volume where source is not “volume” because Nova will attempt to create a volume using the same availability zone as what is assigned to the instance. If that AZ is not in Cinder (or allow_availability_zone_fallback=False in cinder.conf), the volume create request will fail and the instance will fail the build request. |
| endpoint_template = None | (String) Override service catalog lookup with template for cinder endpoint e.g. http://localhost:8776/v1/%(project_id)s |
| http_retries = 3 | (Integer) Number of cinderclient retries on failed http calls |
| insecure = False | (Boolean) Verify HTTPS connections. |
| keyfile = None | (String) PEM encoded client certificate key file |
| os_region_name = None | (String) Region name of this node |
| timeout = None | (Integer) Timeout value for http requests |
| [hyperv] | |
| force_volumeutils_v1 = False | (Boolean) DEPRECATED: Force V1 volume utility class |
| volume_attach_retry_count = 10 | (Integer) The number of times to retry to attach a volume |
| volume_attach_retry_interval = 5 | (Integer) Interval between volume attachment attempts, in seconds |
| [libvirt] | |
| glusterfs_mount_point_base = $state_path/mnt | (String) Directory where the glusterfs volume is mounted on the compute node |
| nfs_mount_options = None | (String) Mount options passed to the NFS client. See section of the nfs man page for details |
| nfs_mount_point_base = $state_path/mnt | (String) Directory where the NFS volume is mounted on the compute node |
| num_aoe_discover_tries = 3 | (Integer) Number of times to rediscover AoE target to find volume |
| num_iscsi_scan_tries = 5 | (Integer) Number of times to rescan iSCSI target to find volume |
| num_iser_scan_tries = 5 | (Integer) Number of times to rescan iSER target to find volume |
| qemu_allowed_storage_drivers = | (List) Protocols listed here will be accessed directly from QEMU. Currently supported protocols: [gluster] |
| rbd_secret_uuid = None | (String) The libvirt UUID of the secret for the rbd_uservolumes |
| rbd_user = None | (String) The RADOS client name for accessing rbd volumes |
| scality_sofs_config = None | (String) Path or URL to Scality SOFS configuration file |
| scality_sofs_mount_point = $state_path/scality | (String) Base dir where Scality SOFS shall be mounted |
| smbfs_mount_options = | (String) Mount options passed to the SMBFS client. See mount.cifs man page for details. Note that the libvirt-qemu uid and gid must be specified. |
| smbfs_mount_point_base = $state_path/mnt | (String) Directory where the SMBFS shares are mounted on the compute node |
| [xenserver] | |
| block_device_creation_timeout = 10 | (Integer) Time to wait for a block device to be created |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| boot_script_template = $pybasedir/nova/cloudpipe/bootscript.template | (String) Template for cloudpipe instance boot script |
| dmz_cidr = | (List) A list of dmz ranges that should be accepted |
| dmz_mask = 255.255.255.0 | (String) Netmask to push into openvpn config |
| dmz_net = 10.0.0.0 | (String) Network to push into openvpn config |
| vpn_flavor = m1.tiny | (String) Flavor for vpn instances |
| vpn_image_id = 0 | (String) Image ID used when starting up a cloudpipe vpn server |
| vpn_ip = $my_ip | (String) Public IP for the cloudpipe VPN servers |
| vpn_key_suffix = -vpn | (String) Suffix to add to project name for vpn key and secgroups |
| vpn_start = 1000 | (Integer) First Vpn port for private networks |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| api_paste_config = api-paste.ini | (String) File name for the paste.deploy config for nova-api |
| client_socket_timeout = 900 | (Integer) Timeout for client connections’ socket operations. If an incoming connection is idle for this number of seconds it will be closed. A value of ‘0’ means wait forever. |
| max_header_line = 16384 | (Integer) Maximum line size of message headers to be accepted. max_header_line may need to be increased when using large tokens (typically those generated by the Keystone v3 API with big service catalogs). |
| secure_proxy_ssl_header = None | (String) The HTTP header used to determine the scheme for the original request, even if it was removed by an SSL terminating proxy. Typical value is “HTTP_X_FORWARDED_PROTO”. |
| ssl_ca_file = None | (String) CA certificate file to use to verify connecting clients |
| ssl_cert_file = None | (String) SSL certificate of API server |
| ssl_key_file = None | (String) SSL private key of API server |
| tcp_keepidle = 600 | (Integer) Sets the value of TCP_KEEPIDLE in seconds for each server socket. Not supported on OS X. |
| wsgi_default_pool_size = 1000 | (Integer) Size of the pool of greenthreads used by wsgi |
| wsgi_keep_alive = True | (Boolean) If False, closes the client socket connection explicitly. |
| wsgi_log_format = %(client_ip)s "%(request_line)s" status: %(status_code)s len: %(body_length)s time: %(wall_seconds).7f | (String) A python format string that is used as the template to generate log lines. The following values can be formatted into it: client_ip, date_time, request_line, status_code, body_length, wall_seconds. |
| Configuration option = Default value | Description |
|---|---|
| [DEFAULT] | |
| console_driver = nova.console.xvp.XVPConsoleProxy | (String) Driver to use for the console proxy |
| console_xvp_conf = /etc/xvp.conf | (String) Generated XVP conf file |
| console_xvp_conf_template = $pybasedir/nova/console/xvp.conf.template | (String) XVP conf template |
| console_xvp_log = /var/log/xvp.log | (String) XVP log file |
| console_xvp_multiplex_port = 5900 | (Integer) Port for XVP to multiplex VNC connections on |
| console_xvp_pid = /var/run/xvp.pid | (String) XVP master process pid file |
| stub_compute = False | (Boolean) Stub calls to compute worker for tests |
| [libvirt] | |
| xen_hvmloader_path = /usr/lib/xen/boot/hvmloader | (String) Location where the Xen hvmloader is kept |
| [xenserver] | |
| agent_path = usr/sbin/xe-update-networking | (String) Path to locate guest agent on the server. Specifies the path in which the XenAPI guest agent should be located. If the agent is present, network configuration is not injected into the image. Used if compute_driver=xenapi.XenAPIDriver and flat_injected=True. Services which consume this: * nova-compute Possible values: * A valid path Related options: * flat_injected * compute_driver |
| agent_resetnetwork_timeout = 60 | (Integer) Number of seconds to wait for agent’s reply to resetnetwork request. This indicates the amount of time xapi ‘agent’ plugin waits for the agent to respond to the ‘resetnetwork’ request specifically. The generic timeout for agent communication agent_timeout is ignored in this case. Services which consume this: * nova-compute Possible values: * Any positive integer Related options: * None |
| agent_timeout = 30 | (Integer) Number of seconds to wait for agent’s reply to a request. Nova configures/performs certain administrative actions on a server with the help of an agent that’s installed on the server. The communication between Nova and the agent is achieved via sharing messages, called records, over xenstore, a shared storage across all the domains on a Xenserver host. Operations performed by the agent on behalf of nova are: ‘version’,’ key_init’, ‘password’,’resetnetwork’,’inject_file’, and ‘agentupdate’. To perform one of the above operations, the xapi ‘agent’ plugin writes the command and its associated parameters to a certain location known to the domain and awaits response. On being notified of the message, the agent performs appropriate actions on the server and writes the result back to xenstore. This result is then read by the xapi ‘agent’ plugin to determine the success/failure of the operation. This config option determines how long the xapi ‘agent’ plugin shall wait to read the response off of xenstore for a given request/command. If the agent on the instance fails to write the result in this time period, the operation is considered to have timed out. Services which consume this: * nova-compute Possible values: * Any positive integer Related options: * agent_version_timeout * agent_resetnetwork_timeout |
| agent_version_timeout = 300 | (Integer) Number of seconds to wait for agent’t reply to version request. This indicates the amount of time xapi ‘agent’ plugin waits for the agent to respond to the ‘version’ request specifically. The generic timeout for agent communication agent_timeout is ignored in this case. During the build process the ‘version’ request is used to determine if the agent is available/operational to perform other requests such as ‘resetnetwork’, ‘password’, ‘key_init’ and ‘inject_file’. If the ‘version’ call fails, the other configuration is skipped. So, this configuration option can also be interpreted as time in which agent is expected to be fully operational. Services which consume this: * nova-compute Possible values: * Any positive integer Related options: * None |
| cache_images = all | (String) Cache glance images locally. all will cache all images, some will only cache images that have the image_property cache_in_nova=True, and none turns off caching entirely |
| check_host = True | (Boolean) Ensure compute service is running on host XenAPI connects to. |
| connection_concurrent = 5 | (Integer) Maximum number of concurrent XenAPI connections. Used only if compute_driver=xenapi.XenAPIDriver |
| connection_password = None | (String) Password for connection to XenServer/Xen Cloud Platform. Used only if compute_driver=xenapi.XenAPIDriver |
| connection_url = None | (String) URL for connection to XenServer/Xen Cloud Platform. A special value of unix://local can be used to connect to the local unix socket. Required if compute_driver=xenapi.XenAPIDriver |
| connection_username = root | (String) Username for connection to XenServer/Xen Cloud Platform. Used only if compute_driver=xenapi.XenAPIDriver |
| default_os_type = linux | (String) Default OS type |
| disable_agent = False | (Boolean) Disables the use of XenAPI agent. This configuration option suggests whether the use of agent should be enabled or not regardless of what image properties are present. Image properties have an effect only when this is set to True. Read description of config option use_agent_default for more information. Services which consume this: * nova-compute Possible values: * True * False Related options: * use_agent_default |
| image_compression_level = None | (Integer) Compression level for images, e.g., 9 for gzip -9. Range is 1-9, 9 being most compressed but most CPU intensive on dom0. |
| image_upload_handler = nova.virt.xenapi.image.glance.GlanceStore | (String) Dom0 plugin driver used to handle image uploads. |
| introduce_vdi_retry_wait = 20 | (Integer) Number of seconds to wait for an SR to settle if the VDI does not exist when first introduced |
| ipxe_boot_menu_url = None | (String) URL to the iPXE boot menu |
| ipxe_mkisofs_cmd = mkisofs | (String) Name and optionally path of the tool used for ISO image creation |
| ipxe_network_name = None | (String) Name of network to use for booting iPXE ISOs |
| iqn_prefix = iqn.2010-10.org.openstack | (String) IQN Prefix |
| login_timeout = 10 | (Integer) Timeout in seconds for XenAPI login. |
| max_kernel_ramdisk_size = 16777216 | (Integer) Maximum size in bytes of kernel or ramdisk images |
| num_vbd_unplug_retries = 10 | (Integer) Maximum number of retries to unplug VBD. if <=0, should try once and no retry |
| ovs_integration_bridge = xapi1 | (String) Name of Integration Bridge used by Open vSwitch |
| remap_vbd_dev = False | (Boolean) Used to enable the remapping of VBD dev (Works around an issue in Ubuntu Maverick) |
| remap_vbd_dev_prefix = sd | (String) Specify prefix to remap VBD dev to (ex. /dev/xvdb -> /dev/sdb) |
| running_timeout = 60 | (Integer) Number of seconds to wait for instance to go to running state |
| sparse_copy = True | (Boolean) Whether to use sparse_copy for copying data on a resize down (False will use standard dd). This speeds up resizes down considerably since large runs of zeros won’t have to be rsynced |
| sr_base_path = /var/run/sr-mount | (String) Base path to the storage repository |
| sr_matching_filter = default-sr:true | (String) Filter for finding the SR to be used to install guest instances on. To use the Local Storage in default XenServer/XCP installations set this flag to other-config:i18n-key=local-storage. To select an SR with a different matching criteria, you could set it to other-config:my_favorite_sr=true. On the other hand, to fall back on the Default SR, as displayed by XenCenter, set this flag to: default-sr:true |
| target_host = None | (String) The iSCSI Target Host |
| target_port = 3260 | (String) The iSCSI Target Port, default is port 3260 |
| torrent_base_url = None | (String) Base URL for torrent files; must contain a slash character (see RFC 1808, step 6) |
| torrent_download_stall_cutoff = 600 | (Integer) Number of seconds a download can remain at the same progress percentage w/o being considered a stall |
| torrent_images = none | (String) Whether or not to download images via Bit Torrent. |
| torrent_listen_port_end = 6891 | (Integer) End of port range to listen on |
| torrent_listen_port_start = 6881 | (Integer) Beginning of port range to listen on |
| torrent_max_last_accessed = 86400 | (Integer) Cached torrent files not accessed within this number of seconds can be reaped |
| torrent_max_seeder_processes_per_host = 1 | (Integer) Maximum number of seeder processes to run concurrently within a given dom0. (-1 = no limit) |
| torrent_seed_chance = 1.0 | (Floating point) Probability that peer will become a seeder. (1.0 = 100%) |
| torrent_seed_duration = 3600 | (Integer) Number of seconds after downloading an image via BitTorrent that it should be seeded for other peers. |
| use_agent_default = False | (Boolean) Whether or not to use the agent by default when its usage is enabled but not indicated by the image. The use of XenAPI agent can be disabled altogether using the configuration option disable_agent. However, if it is not disabled, the use of an agent can still be controlled by the image in use through one of its properties, xenapi_use_agent. If this property is either not present or specified incorrectly on the image, the use of agent is determined by this configuration option. Note that if this configuration is set to True when the agent is not present, the boot times will increase significantly. Services which consume this: * nova-compute Possible values: * True * False Related options: * disable_agent |
| use_join_force = True | (Boolean) To use for hosts with different CPUs |
| vhd_coalesce_max_attempts = 20 | (Integer) Max number of times to poll for VHD to coalesce. Used only if compute_driver=xenapi.XenAPIDriver |
| vhd_coalesce_poll_interval = 5.0 | (Floating point) The interval used for polling of coalescing vhds. Used only if compute_driver=xenapi.XenAPIDriver |
| vif_driver = nova.virt.xenapi.vif.XenAPIBridgeDriver | (String) The XenAPI VIF driver using XenServer Network APIs. |
Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.