debops.netbox default variables

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_local.core.domain
                    if (ansible_local|d() and ansible_local.core|d() and
                        ansible_local.core.domain|d())
                    else 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'
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.root.home
                   if (ansible_local|d() and ansible_local.root|d() and
                       ansible_local.root.home|d())
                   else "/var/local") + "/" + netbox__user }}'
netbox__src

Directory where the role stores NetBox sources from GitHub.

netbox__src: '{{ (ansible_local.root.src
                  if (ansible_local|d() and ansible_local.root|d() and
                      ansible_local.root.src|d())
                  else "/usr/local/src") + "/" + netbox__user }}'
netbox__lib

Directory where the NetBox application directory is located.

netbox__lib: '{{ (ansible_local.root.lib
                  if (ansible_local|d() and ansible_local.root|d() and
                      ansible_local.root.lib|d())
                  else "/usr/local/lib") + "/" + netbox__user }}'
netbox__data

Directory where custom Netbox data (images, scripts) outside of the database is stored.

netbox__data: '{{ (ansible_local.root.data
                   if (ansible_local|d() and ansible_local.root|d() and
                       ansible_local.root.data|d())
                   else "/srv") + "/" + netbox__user }}'

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.6.1'
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
                 if (ansible_local|d() and ansible_local.gunicorn|d() and
                     ansible_local.gunicorn.version|d())
                 else omit }}'
  - 'setproctitle'
  - name: 'napalm'
    state: '{{ "present"
               if (netbox__config_napalm_password != "")
               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
                           if (ansible_local|d() and ansible_local.postgresql|d() and
                               ansible_local.postgresql.server|d())
                           else "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
                           if (ansible_local|d() and ansible_local.postgresql|d() and
                               ansible_local.postgresql.port|d())
                           else "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
                                if (ansible_local|d() and ansible_local.postgresql|d() and
                                    ansible_local.postgresql.delegate_to|d())
                                else "localhost") + "/" +
                               (ansible_local.postgresql.port
                                if (ansible_local|d() and ansible_local.postgresql|d() and
                                    ansible_local.postgresql.port|d())
                                else "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
                         if (ansible_local|d() and ansible_local.redis_server|d() and
                             ansible_local.redis_server.host|d())
                         else "localhost" }}'
netbox__redis_port

Define port of Redis server to use.

netbox__redis_port: '{{ ansible_local.redis_server.port
                        if (ansible_local|d() and ansible_local.redis_server|d() and
                            ansible_local.redis_server.port|d())
                        else "6379" }}'
netbox__redis_password

Define the Redis authentication password to use.

netbox__redis_password: '{{ ansible_local.redis_server.password
                            if (ansible_local|d() and ansible_local.redis_server|d() and
                                ansible_local.redis_server.password|d())
                            else "" }}'
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 chache.

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

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 OCRS origin hostnames.

netbox__config_cors_origin_whitelist: []
netbox__config_cors_origin_regex_whitelist

List of allowed OCRS 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 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_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__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_time_zone

Specify the timezone used by NetBox.

netbox__config_time_zone: '{{ ansible_local.timezone
                              if (ansible_local|d() and
                                  ansible_local.timezone|d())
                              else "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_webhooks_enabled

The webhooks backend is disabled by default. Set this to True to enable it. Note that this requires a Redis # database be configured and accessible by NetBox.

netbox__config_webhooks_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 Nebox stores upladed 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" }}'

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]
                            if (ansible_local|d() and ansible_local.core|d() and
                                ansible_local.core.admin_users|d())
                            else "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]
                             if (ansible_local|d() and ansible_local.core|d() and
                                 ansible_local.core.admin_private_email|d())
                             else ("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: '{{ False
                                    if (ansible_local|d() and ansible_local.gunicorn|d() and
                                        ansible_local.gunicorn.installed|bool)
                                    else (True if ansible_service_mgr == "systemd" else False) }}'
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__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'
    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"';