debops.netbox default variables
Sections
Domain name configuration
- netbox__fqdn
String or list of the Fully Qualified domain names on which the NetBox application will be available, used by the webserver. The first item will be used as the e-mail sender domain name.
netbox__fqdn: [ 'dcim.{{ netbox__domain }}', 'ipam.{{ netbox__domain }}' ]
- netbox__domain
The DNS domain used by other variables in the debops.netbox
role.
netbox__domain: '{{ ansible_domain }}'
APT packages
- netbox__base_packages
List of APT packages which are required by the NetBox application.
netbox__base_packages:
- 'git'
- 'build-essential'
- 'libxml2-dev'
- 'libxslt1-dev'
- 'libffi-dev'
- 'graphviz'
- 'libpq-dev'
- 'libssl-dev'
- '{{ [ "libldap2-dev", "libsasl2-dev" ]
if netbox__ldap_enabled|bool
else [] }}'
- netbox__packages
List of additional APT packages to install with NetBox.
netbox__packages: []
Application user, group, home
- netbox__user
Name of the UNIX system account used to manage NetBox.
netbox__user: 'netbox'
- netbox__group
Name of the UNIX primary group used to manage NetBox.
netbox__group: 'netbox'
- netbox__gecos
Contents of the GECOS field set for the NetBox account.
netbox__gecos: 'NetBox'
- netbox__shell
The default shell set on the NetBox account.
netbox__shell: '/usr/sbin/nologin'
Directory paths
- netbox__home
The NetBox account home directory.
netbox__home: '{{ (ansible_local.fhs.home | d("/var/local"))
+ "/" + netbox__user }}'
- netbox__src
Directory where the role stores NetBox sources from GitHub.
netbox__src: '{{ (ansible_local.fhs.src | d("/usr/local/src"))
+ "/" + netbox__user }}'
- netbox__lib
Directory where the NetBox application directory is located.
netbox__lib: '{{ (ansible_local.fhs.lib | d("/usr/local/lib"))
+ "/" + netbox__user }}'
- netbox__data
Directory where custom NetBox data (images, scripts) outside of the database is stored.
netbox__data: '{{ (ansible_local.fhs.data | d("/srv"))
+ "/" + netbox__user }}'
- netbox__bin
Directory where helper scripts for NetBox power users are stored.
netbox__bin: '{{ ansible_local.fhs.bin | d("/usr/local/bin") }}'
Application sources and deployment
- netbox__git_gpg_key_id
The GPG ID of the key used for signing NetBox releases. At the moment the releases are signed using GitHub GPG key.
netbox__git_gpg_key_id: '5DE3 E050 9C47 EA3C F04A 42D3 4AEE 18F8 3AFD EB23'
- netbox__git_repo
The URI of the NetBox git source repository.
netbox__git_repo: 'https://github.com/netbox-community/netbox.git'
- netbox__git_version
The git branch or tag which will be installed.
netbox__git_version: 'v2.11.2'
- netbox__git_dest
Path where the git source bare repository will be stored.
netbox__git_dest: '{{ netbox__src + "/" + netbox__git_repo.split("://")[1] }}'
- netbox__git_checkout
Path where NetBox sources will be checked out (installation path).
netbox__git_checkout: '{{ netbox__virtualenv + "/app" }}'
Python virtualenv configuration
- netbox__virtualenv_version
Beginning with v2.5, NetBox will no longer support Python 2. When this is set to 3 a new Python 3 virtualenv environment will be created next to the old one. Valid values are 3 or an empty string.
netbox__virtualenv_version: '{{ ""
if ( netbox__git_version | regex_search("^v?[0-9\.]+")
and netbox__git_version|replace("v", "") is version("2.5", "<") )
else "3" }}'
- netbox__virtualenv
Path where the NetBox virtualenv
directory will be stored.
netbox__virtualenv: '{{ netbox__lib + "/virtualenv" }}'
- netbox__virtualenv_env_path
The contents of the $PATH
environment variable set for the Ansible tasks
which are executed inside of the NetBox Python environment.
netbox__virtualenv_env_path: '{{ netbox__virtualenv }}/bin:/usr/local/bin:/usr/bin:/bin'
- netbox__virtualenv_pip_packages
List of additional Python modules installed inside of the NetBox
virtualenv
environment. See netbox__virtualenv_pip_packages
for more details.
netbox__virtualenv_pip_packages:
- name: 'gunicorn'
version: '{{ ansible_local.gunicorn.version|d(omit) }}'
- 'setproctitle'
- name: 'napalm'
state: '{{ "present"
if (netbox__config_napalm_username|d() or netbox__napalm_ssh_generate|bool)
else "ignore" }}'
- name: 'django-auth-ldap'
state: '{{ "present" if netbox__ldap_enabled|bool else "ignore" }}'
PostgreSQL database configuration
The NetBox database configuration is managed by the debops.postgresql Ansible role. See its documentation for details about the default variable values used in the NetBox role.
- netbox__database_host
The hostname or IP address of the PostgreSQL database server to use for the NetBox database.
netbox__database_host: '{{ ansible_local.postgresql.server|d("localhost") }}'
- netbox__database_port
The TCP port of the PostgreSQL database server which should be used by NetBox.
netbox__database_port: '{{ ansible_local.postgresql.port|d("5432") }}'
- netbox__database_name
Name of the PostgreSQL database and its corresponding role used by NetBox. This role won't be able to login to the database server directly.
netbox__database_name: 'netbox_production'
- netbox__database_user
Name of the PostgreSQL role used by NetBox. This role will be able to login to the PostgreSQL server and access the NetBox database.
netbox__database_user: '{{ netbox__user }}'
- netbox__database_password
Autogenerated password to the NetBox PostgreSQL user role.
netbox__database_password: '{{ lookup("password", secret + "/postgresql/" +
(ansible_local.postgresql.delegate_to|d("localhost")) + "/" +
(ansible_local.postgresql.port|d("5432")) + "/credentials/" +
netbox__database_user + "/password") }}'
- netbox__load_initial_data
If True
, the role will populate the NetBox database with the initial data
provided with the application on installation.
netbox__load_initial_data: True
Redis database configuration
The Redis database configuration is managed by the debops.redis_server Ansible role. See its documentation for details about the default variable values used in the NetBox role.
- netbox__redis_host
Define hostname of the Redis server to use.
netbox__redis_host: '{{ ansible_local.redis_server.host|d("localhost") }}'
- netbox__redis_port
Define port of Redis server to use.
netbox__redis_port: '{{ ansible_local.redis_server.port|d("6379") }}'
- netbox__redis_password
Define the Redis authentication password to use.
netbox__redis_password: '{{ ansible_local.redis_server.password|d("") }}'
- netbox__redis_database
Specify which Redis database to use for NetBox.
netbox__redis_database: '0'
- netbox__redis_cache_database
Specify which Redis database to use for NetBox cache.
netbox__redis_cache_database: '{{ (netbox__redis_database|int + 1) }}'
- netbox__redis_ssl
Enable or disable support for encrypted connections to Redis. Currently this option has no support in DebOps.
netbox__redis_ssl: False
LDAP environment
- netbox__ldap_enabled
Enable or disable support for LDAP authentication in NetBox.
netbox__ldap_enabled: '{{ True
if (ansible_local|d() and ansible_local.ldap|d() and
(ansible_local.ldap.enabled|d())|bool)
else False }}'
- netbox__ldap_base_dn
The base Distinguished Name which should be used to create Distinguished Names of the LDAP directory objects, defined as a YAML list. If this variable is empty, LDAP configuration will not be performed.
netbox__ldap_base_dn: '{{ ansible_local.ldap.base_dn|d([]) }}'
- netbox__ldap_device_dn
The Distinguished Name of the current host LDAP object, defined as a YAML list. It will be used as a base for the NetBox service account LDAP object. If the list is empty, the role will not create the account LDAP object automatically.
netbox__ldap_device_dn: '{{ ansible_local.ldap.device_dn|d([]) }}'
- netbox__ldap_self_rdn
The Relative Distinguished Name of the account LDAP object used by the NetBox service to access the LDAP directory.
netbox__ldap_self_rdn: 'uid=netbox'
- netbox__ldap_self_object_classes
List of the LDAP object classes which will be used to create the LDAP object used by the NetBox service to access the LDAP directory.
netbox__ldap_self_object_classes: [ 'account', 'simpleSecurityObject' ]
- netbox__ldap_self_attributes
YAML dictionary that defines the attributes of the LDAP object used by the NetBox service to access the LDAP directory.
netbox__ldap_self_attributes:
uid: '{{ netbox__ldap_self_rdn.split("=")[1] }}'
userPassword: '{{ netbox__ldap_bindpw }}'
host: '{{ [ ansible_fqdn, ansible_hostname ] | unique }}'
description: 'Account used by the "NetBox" service to access the LDAP directory'
- netbox__ldap_binddn
The Distinguished Name of the account LDAP object used by the NetBox service to bind to the LDAP directory.
netbox__ldap_binddn: '{{ ([ netbox__ldap_self_rdn ] + netbox__ldap_device_dn) | join(",") }}'
- netbox__ldap_bindpw
The password stored in the account LDAP object used by the NetBox service to bind to the LDAP directory.
netbox__ldap_bindpw: '{{ (lookup("password", secret + "/ldap/credentials/"
+ netbox__ldap_binddn | to_uuid + ".password length=32"))
if netbox__ldap_enabled|bool
else "" }}'
- netbox__ldap_people_rdn
The Relative Distinguished Name of the LDAP object which contains the user accounts stored in LDAP.
netbox__ldap_people_rdn: '{{ ansible_local.ldap.people_rdn|d("ou=People") }}'
- netbox__ldap_people_dn
The Distinguished Name of the LDAP object which contains the user accounts used by NetBox.
netbox__ldap_people_dn: '{{ [ netbox__ldap_people_rdn ] + netbox__ldap_base_dn }}'
- netbox__ldap_group_authentication_enabled
Enable or disable user authentication using LDAP groups.
netbox__ldap_group_authentication_enabled: True
- netbox__ldap_private_groups
When this variable is enabled, the debops.ldap role will create
a separate LDAP objects that manage the NetBox groups as subtree of the
NetBox service LDAP object. If you set this parameter to False
, the
role will use the global ou=Groups,dc=example,dc=org
subtree instead.
netbox__ldap_private_groups: True
- netbox__ldap_groups_rdn
The Relative Distinguished Name of the LDAP object which contains the groups stored in LDAP.
netbox__ldap_groups_rdn: '{{ ansible_local.ldap.groups_rdn|d("ou=Groups") }}'
- netbox__ldap_groups_dn
The Distinguished Name of the LDAP object which contains the groups used by NetBox. If private groups are enabled, this object will be created automatically.
netbox__ldap_groups_dn: '{{ ([ netbox__ldap_groups_rdn, netbox__ldap_self_rdn ]
+ netbox__ldap_device_dn)
if netbox__ldap_private_groups|bool
else ([ netbox__ldap_groups_rdn ] + netbox__ldap_base_dn) }}'
- netbox__ldap_user_group_rdn
The Relative Distinguished Name of the LDAP object which defines the group of NetBox users on a given NetBox instance.
netbox__ldap_user_group_rdn: 'cn=NetBox Users'
- netbox__ldap_user_group_dn
The Distinguished Name of the LDAP object which defines who defines the group of NetBox users on a given NetBox instance.
netbox__ldap_user_group_dn: '{{ [ netbox__ldap_user_group_rdn ]
+ netbox__ldap_groups_dn }}'
- netbox__ldap_user_active_group_rdn
The Relative Distinguished Name of the LDAP object which defines who has active access to a given NetBox instance.
netbox__ldap_user_active_group_rdn: 'cn=NetBox Active Users'
- netbox__ldap_user_active_group_dn
The Distinguished Name of the LDAP object which defines who has access to a given NetBox instance.
netbox__ldap_user_active_group_dn: '{{ [ netbox__ldap_user_active_group_rdn ]
+ netbox__ldap_groups_dn }}'
- netbox__ldap_user_staff_group_rdn
The Relative Distinguished Name of the LDAP object which defines who has staff access level to a given NetBox instance and can have permissions in NetBox ACL system.
netbox__ldap_user_staff_group_rdn: 'cn=NetBox Staff'
- netbox__ldap_user_staff_group_dn
The Distinguished Name of the LDAP object which defines who has staff access level to a given NetBox instance and can have premissions in NetBox ACL system.
netbox__ldap_user_staff_group_dn: '{{ [ netbox__ldap_user_staff_group_rdn ]
+ netbox__ldap_groups_dn }}'
- netbox__ldap_user_admin_group_rdn
The Relative Distinguished Name of the LDAP object which defines who has superuser access level to a given NetBox instance.
netbox__ldap_user_admin_group_rdn: 'cn=NetBox Administrators'
- netbox__ldap_user_admin_group_dn
The Distinguished Name of the LDAP object which defines who has superuser access level to a given NetBox instance.
netbox__ldap_user_admin_group_dn: '{{ [ netbox__ldap_user_admin_group_rdn ]
+ netbox__ldap_groups_dn }}'
- netbox__ldap_object_owner_rdn
The Relative Distinguished Name of the LDAP object of the person who installed a given NetBox instance and is used as the owner of the "NetBox Administrators" group.
netbox__ldap_object_owner_rdn: 'uid={{ lookup("env", "USER") }}'
- netbox__ldap_object_ownerdn
The Distinguished Name of the LDAP object of the person who installed a given NetBox instance and is used as the owner of the "NetBox Administrators" group, defined as a string.
netbox__ldap_object_ownerdn: '{{ ([ netbox__ldap_object_owner_rdn, netbox__ldap_people_rdn ]
+ netbox__ldap_base_dn) | join(",") }}'
LDAP connection options
- netbox__ldap_server_uri
The URI address of the LDAP server used by NetBox.
netbox__ldap_server_uri: '{{ ansible_local.ldap.uri|d([""]) | first }}'
- netbox__ldap_server_port
The TCP port which should be used for connections to the LDAP server.
netbox__ldap_server_port: '{{ ansible_local.ldap.port|d("389" if netbox__ldap_start_tls|bool else "636") }}'
- netbox__ldap_start_tls
If True
, NetBox will use STARTTLS extension to make encrypted
connections to the LDAP server.
netbox__ldap_start_tls: '{{ ansible_local.ldap.start_tls
if (ansible_local|d() and ansible_local.ldap|d() and
(ansible_local.ldap.start_tls|d())|bool)
else True }}'
- netbox__ldap_user_filter
The LDAP filter used to look up user accounts in the directory.
netbox__ldap_user_filter: '(uid=%(user)s)'
NetBox configuration options
- netbox__config_allowed_hosts
List of domain names under which the NetBox application will accept
connections. Specify *
to accept connections to any domain name.
netbox__config_allowed_hosts: '{{ netbox__fqdn }}'
- netbox__config_secret_key
The Django secret key used by the NetBox application. It will be shared by all hosts on the same domain.
netbox__config_secret_key: '{{ lookup("password", secret + "/netbox/" +
netbox__domain + "/config/secret_key length=64") }}'
- netbox__config_admins
A YAML list of tuples, [ 'Name', 'email' ]
, of the NetBox administrators.
They will receive e-mail messages about NetBox application errors.
By default the role uses the list of private admin e-mails from the debops.core Ansible role.
netbox__config_admins: '{{ lookup("template", "lookup/netbox__config_admins.j2") | from_yaml }}'
- netbox__config_cache_timeout
Cache timeout in seconds. Set to 0 to disable caching.
netbox__config_cache_timeout: 3600
- netbox__config_changelog_retention
Maximum number of days to retain logged changes. Set to 0 to retain changes indefinitely.
netbox__config_changelog_retention: 90
- netbox__config_cors_origin_allow_all
API Cross-Origin Resource Sharing configuration. If True
, all origins are
allowed. See https://github.com/ottoyiu/django-cors-headers for more details.
netbox__config_cors_origin_allow_all: False
- netbox__config_cors_origin_whitelist
List of allowed CORS origin hostnames.
netbox__config_cors_origin_whitelist: []
- netbox__config_cors_origin_regex_whitelist
List of allowed CORS origin regex hostnames.
netbox__config_cors_origin_regex_whitelist: []
- netbox__config_email_server
The address of the SMTP server used by NetBox. By default the application uses a locally-installed SMTP server.
netbox__config_email_server: 'localhost'
- netbox__config_email_port
The TCP port of the SMTP server used by NetBox.
netbox__config_email_port: '25'
- netbox__config_email_username
The username used to login to the SMTP server.
netbox__config_email_username: ''
- netbox__config_email_password
The password used to login to the SMTP server.
netbox__config_email_password: ''
- netbox__config_email_use_tls
Use TLS (previously known as SSL) when connecting to the SMTP server.
netbox__config_email_use_tls: True
- netbox__config_email_timeout
The SMTP server connection timeout, in seconds.
netbox__config_email_timeout: '10'
- netbox__config_email_from
The e-mail address for the NetBox application, it will be used in the
From:
header of the NetBox e-mail messages.
netbox__config_email_from: '{{ netbox__user }}@{{ netbox__fqdn
if netbox__fqdn is string
else netbox__fqdn[0] }}'
- netbox__config_logging
Optional, custom logging configuration specified as YAML dictionary. See https://docs.djangoproject.com/en/1.11/topics/logging for more details.
netbox__config_logging: {}
- netbox__config_login_required
If True
, access to NetBox is only allowed for logged-in users. If
False
, some information stored in the NetBox database is accessible in
the read-only mode for anonymous users.
netbox__config_login_required: True
- netbox__config_login_timeout
The length of time (in seconds) for which a user will remain logged into the web UI before being prompted to re-authenticate. (Default: 14 days)
netbox__config_login_timeout: '{{ (60 * 60 * 24 * 14) }}'
- netbox__config_base_path
Set the "base path" of the NetBox application if it's installed in a subdirectory of the webserver.
netbox__config_base_path: ''
- netbox__config_maintenance_mode
Enable or disable maintenance mode banner.
netbox__config_maintenance_mode: False
- netbox__config_napalm_username
Specify the username which should be used by NetBox to access live devices using the NAPALM library.
netbox__config_napalm_username: ''
- netbox__config_napalm_password
Specify the password which should be used by NetBox to access live devices using the NAPALM library.
netbox__config_napalm_password: ''
- netbox__napalm_ssh_generate
Generate ~/.ssh/id_rsa
SSH private and public key if it doesn't
exist.
netbox__napalm_ssh_generate: False
- netbox__napalm_ssh_generate_bits
Size of the generated SSH key.
netbox__napalm_ssh_generate_bits: '2048'
- netbox__config_napalm_timeout
NAPALM request timeout, in seconds.
netbox__config_napalm_timeout: '30'
- netbox__config_napalm_args
Optional NAPALM arguments, specified as a YAML dictionary.
netbox__config_napalm_args: {}
- netbox__config_paginate_count
Specify maximum number of list items per page.
netbox__config_paginate_count: '64'
- netbox__config_max_page_size
Maximum number of objects returned in an API call.
netbox__config_max_page_size: '1000'
- netbox__config_maps_url
The URL to use when mapping physical addresses or GPS coordinates. Note that NetBox defaults to Google Maps.
netbox__config_maps_url: 'https://www.openstreetmap.org/search?query='
- netbox__config_time_zone
Specify the timezone used by NetBox.
netbox__config_time_zone: '{{ ansible_local.tzdata.timezone | d("Etc/UTC") }}'
- netbox__config_date_format
Specify the date format which NetBox uses to display information. See https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date for more details.
netbox__config_date_format: 'N j, Y'
- netbox__config_short_date_format
Specify the short date format used by NetBox to display information.
netbox__config_short_date_format: 'Y-m-d'
- netbox__config_time_format
Specify the time format used by NetBox to display information.
netbox__config_time_format: 'g:i a'
- netbox__config_short_time_format
Specify the short time format used by NetBox to display information.
netbox__config_short_time_format: 'H:i:s'
- netbox__config_datetime_format
Specify the date and time format used by NetBox to display information.
netbox__config_datetime_format: 'N j, Y g:i a'
- netbox__config_short_datetime_format
Specify the short date and time format used by NetBox to display information.
netbox__config_short_datetime_format: 'Y-m-d H:i'
- netbox__config_banner_top
Specify a custom message displayed on the top of every page.
netbox__config_banner_top: ''
- netbox__config_banner_bottom
Specify a custom message displayed on the bottom of every page.
netbox__config_banner_bottom: ''
- netbox__config_banner_login
Specify a custom message displayed on the login page above the login from.
netbox__config_banner_login: ''
- netbox__config_prefer_ipv4
By default NetBox prefers to use IPv6 addresses as primary device addresses.
Set this variable to True
to change that to IPv4 instead.
netbox__config_prefer_ipv4: False
- netbox__config_enforce_global_unique
If enabled, NetBox will enforce unique IP space in the "global" table (all prefixes and IP addresses not included in a VRF).
netbox__config_enforce_global_unique: False
- netbox__config_exempt_view_permissions
Exempt certain models from the enforcement of view permissions. Models listed here will be viewable by all users and by anonymous users. List models in the form <app>.<model>. Add '*' to this list to exempt all models.
netbox__config_exempt_view_permissions: []
- netbox__config_metrics_enabled
When enabled, expose Prometheus monitoring metrics at the HTTP endpoint '/metrics'.
netbox__config_metrics_enabled: False
- netbox__config_session_file_path
By default, NetBox will store session data in the database. Alternatively, a file path can be specified here to use local file storage instead. (This can be useful for enabling authentication on a standby instance with read-only database access.) Note that the user as which NetBox runs must have read and write permissions to this path.
netbox__config_session_file_path: False
- netbox__config_media_root
Absolute path where NetBox stores uploaded media files.
netbox__config_media_root: '{{ netbox__data + "/media" }}'
- netbox__config_reports_root
Absolute path where NetBox reports (Python modules) are stored.
netbox__config_reports_root: '{{ netbox__data + "/reports" }}'
- netbox__config_scripts_root
Absolute path where NetBox scripts (Python modules) are stored.
netbox__config_scripts_root: '{{ netbox__data + "/scripts" }}'
- netbox__config_plugins
List of NetBox plugins.
netbox__config_plugins: []
- netbox__config_plugins_config
NetBox plugins configuration settings. See netbox__config_plugins_config for more details.
netbox__config_plugins_config: {}
- netbox__config_custom
Additional configuration not directly supported by this role can be specified with this string variable.
netbox__config_custom: ''
Initial superuser account
- netbox__superuser_name
Name of the initial admin account created by the role.
netbox__superuser_name: '{{ ansible_local.core.admin_users[0]|d("admin") }}'
- netbox__superuser_email
E-mail address of the initial admin account created by the role.
netbox__superuser_email: '{{ ansible_local.core.admin_private_email[0]
|d("root@" + netbox__domain) }}'
- netbox__superuser_password
Password set for the initial admin account created by the role.
netbox__superuser_password: '{{ lookup("password", secret + "/netbox/" +
netbox__domain + "/superuser/" +
netbox__superuser_name + "/password") }}'
Internal application settings
- netbox__app_internal_appserver
Enable or disable support for internal gunicorn
application server.
netbox__app_internal_appserver: '{{ ansible_local.gunicorn.installed
|d(ansible_service_mgr == "systemd")|bool }}'
- netbox__app_name
Name of the NetBox application processes (workers) set by the master process.
netbox__app_name: '{{ netbox__user }}'
- netbox__app_runtime_dir
Name of the subdirectory in the /run/
directory where the NetBox
application will bind its UNIX socket. The default is selected so that
configuration of the gunicorn
service is idempotent.
netbox__app_runtime_dir: '{{ "gunicorn"
if (ansible_distribution_release in
[ "wheezy", "jessie", "precise", "trusty", "xenial" ])
else "gunicorn-netbox" }}'
- netbox__app_bind
Specify either an UNIX or TCP socket on which the NetBox application should bind and listen for connections.
netbox__app_bind: 'unix:/run/{{ netbox__app_runtime_dir }}/netbox.sock'
- netbox__app_workers
Number of worker threads to start for NetBox application.
netbox__app_workers: '{{ ansible_processor_vcpus|int + 1 }}'
- netbox__app_timeout
Number of seconds after which non-responsive worker threads will be killed and restarted. NetBox installations with lots of objects might require longer timeouts for API access.
netbox__app_timeout: '900'
- netbox__app_params
List of parameters passed to the gunicorn
process manager.
netbox__app_params:
- '--name={{ netbox__app_name }}'
- '--bind={{ netbox__app_bind }}'
- '--workers={{ netbox__app_workers }}'
- '--timeout={{ netbox__app_timeout }}'
- 'netbox.wsgi'
Configuration variables for other Ansible roles
- netbox__keyring__dependent_gpg_keys
Configuration for the debops.keyring Ansible role.
netbox__keyring__dependent_gpg_keys:
- user: '{{ netbox__user }}'
group: '{{ netbox__group }}'
home: '{{ netbox__home }}'
id: '{{ netbox__git_gpg_key_id }}'
- netbox__python__dependent_packages3
Configuration for the debops.python Ansible role.
netbox__python__dependent_packages3:
- 'python3-dev'
- netbox__python__dependent_packages2
Configuration for the debops.python Ansible role.
netbox__python__dependent_packages2:
- 'python-dev'
- netbox__ldap__dependent_tasks
Configuration for the debops.ldap Ansible role.
netbox__ldap__dependent_tasks:
- name: 'Create NetBox account for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_binddn }}'
objectClass: '{{ netbox__ldap_self_object_classes }}'
attributes: '{{ netbox__ldap_self_attributes }}'
no_log: '{{ debops__no_log | d(True) }}'
state: '{{ "present" if netbox__ldap_device_dn|d() else "ignore" }}'
- name: 'Create NetBox group container for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_groups_dn }}'
objectClass: 'organizationalStructure'
attributes:
ou: '{{ netbox__ldap_groups_rdn.split("=")[1] }}'
description: 'User groups used in NetBox'
state: '{{ "present"
if (netbox__ldap_device_dn|d() and
netbox__ldap_private_groups|bool)
else "ignore" }}'
- name: 'Create NetBox user group for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_user_group_dn }}'
objectClass: 'groupOfNames'
attributes:
cn: '{{ netbox__ldap_user_group_rdn.split("=")[1] }}'
owner: '{{ netbox__ldap_object_ownerdn }}'
member: '{{ netbox__ldap_object_ownerdn }}'
state: '{{ "present" if netbox__ldap_device_dn|d() else "ignore" }}'
- name: 'Create NetBox active user group for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_user_active_group_dn }}'
objectClass: 'groupOfNames'
attributes:
cn: '{{ netbox__ldap_user_active_group_rdn.split("=")[1] }}'
owner: '{{ netbox__ldap_object_ownerdn }}'
member: '{{ netbox__ldap_object_ownerdn }}'
state: '{{ "present" if netbox__ldap_device_dn|d() else "ignore" }}'
- name: 'Create NetBox staff group for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_user_staff_group_dn }}'
objectClass: 'groupOfNames'
attributes:
cn: '{{ netbox__ldap_user_staff_group_rdn.split("=")[1] }}'
owner: '{{ netbox__ldap_object_ownerdn }}'
member: '{{ netbox__ldap_object_ownerdn }}'
state: '{{ "present" if netbox__ldap_device_dn|d() else "ignore" }}'
- name: 'Create NetBox admin group for {{ netbox__ldap_device_dn | join(",") }}'
dn: '{{ netbox__ldap_user_admin_group_dn }}'
objectClass: 'groupOfNames'
attributes:
cn: '{{ netbox__ldap_user_admin_group_rdn.split("=")[1] }}'
owner: '{{ netbox__ldap_object_ownerdn }}'
member: '{{ netbox__ldap_object_ownerdn }}'
state: '{{ "present" if netbox__ldap_device_dn|d() else "ignore" }}'
- netbox__gunicorn__dependent_applications
Configuration for the debops.gunicorn Ansible role.
netbox__gunicorn__dependent_applications:
- name: 'netbox'
mode: 'wsgi'
working_dir: '{{ netbox__git_checkout + "/netbox" }}'
python: '{{ netbox__virtualenv + "/bin/python" }}'
user: '{{ netbox__user }}'
group: '{{ netbox__group }}'
home: '{{ netbox__home }}'
system: True
timeout: '{{ netbox__app_timeout }}'
workers: '{{ netbox__app_workers }}'
args: '{{ netbox__app_params }}'
- netbox__postgresql__dependent_roles
Role configuration for the debops.postgresql Ansible role.
netbox__postgresql__dependent_roles:
- name: '{{ netbox__database_user }}'
- name: '{{ netbox__database_name }}'
flags: [ 'NOLOGIN' ]
- netbox__postgresql__dependent_groups
Group configuration for the debops.postgresql Ansible role.
netbox__postgresql__dependent_groups:
- roles: [ '{{ netbox__database_user }}' ]
groups: [ '{{ netbox__database_name }}' ]
database: '{{ netbox__database_name }}'
- netbox__postgresql__dependent_databases
Database configuration for the debops.postgresql Ansible role.
netbox__postgresql__dependent_databases:
- name: '{{ netbox__database_name }}'
owner: '{{ netbox__database_name }}'
- netbox__postgresql__dependent_pgpass
~/.pgpass
configuration for the debops.postgresql Ansible role.
netbox__postgresql__dependent_pgpass:
- owner: '{{ netbox__user }}'
group: '{{ netbox__group }}'
home: '{{ netbox__home }}'
system: True
- netbox__nginx__dependent_upstreams
Upstream configuration for the debops.nginx Ansible role.
netbox__nginx__dependent_upstreams:
- name: 'netbox'
server: '{{ netbox__app_bind }}'
- netbox__nginx__dependent_servers
Server configuration for the debops.nginx Ansible role.
netbox__nginx__dependent_servers:
- name: '{{ netbox__fqdn }}'
by_role: 'debops.netbox'
filename: 'debops.netbox'
options: |
client_max_body_size 25m;
location:
'/static/': |
alias {{ netbox__git_checkout }}/netbox/static/;
'/': |
proxy_pass http://netbox;
proxy_set_header X-Forwarded-Host $server_name;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout {{ netbox__app_timeout }};
proxy_send_timeout {{ netbox__app_timeout }};
proxy_read_timeout {{ netbox__app_timeout }};
add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';