debops.netbox default variables¶

Sections

Domain name configuration
APT packages
Application user, group, home
Directory paths
Application sources and deployment
Python virtualenv configuration
PostgreSQL database configuration
Redis database configuration
NetBox configuration options
Initial superuser account
Internal application settings
Configuration variables for other Ansible roles

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'

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.6.3'

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" }}'

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
                                if (ansible_local.postgresql.delegate_to|d())
                                else "localhost") + "/" +
                               (ansible_local.postgresql.port
                                if (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|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 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__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_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_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 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_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]
                            if (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.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'
    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"';