Building Your Development Environment¶
The development environment can be used in two ways:
RecommendedAll services are spun up using Docker and a local mount so you can develop locally, but Nautobot is spun up within the Docker container.
- With a local poetry environment if you wish to develop outside of Docker with the caveat of using external services provided by Docker for PostgresQL and Redis.
This is a quick reference guide if you're already familiar with the development environment provided, which you can read more about later in this document.
The Invoke library is used to provide some helper commands based on the environment. There are a few configuration parameters which can be passed to Invoke to override the default configuration:
nautobot_ver: the version of Nautobot to use as a base for any built docker containers (default: latest)
project_name: the default docker compose project name (default:
python_ver: the version of Python to use as a base for any built docker containers (default: 3.8)
local: a boolean flag indicating if invoke tasks should be run on the host or inside the docker containers (default: False, commands will be run in docker containers)
compose_dir: the full path to a directory containing the project compose files
compose_files: a list of compose files applied in order (see Multiple Compose files for more information)
Using Invoke these configuration options can be overridden using several methods. Perhaps the simplest is setting an environment variable
VARIABLE_NAME is the variable you are trying to override. The only exception is
compose_files, because it is a list it must be overridden in a YAML file. There is an example
invoke.example.yml) in this directory which can be used as a starting point.
Docker Development Environment¶
This is the recommended option for development.
This project is managed by Python Poetry and has a few requirements to setup your development environment:
- Install Poetry, see the Poetry Documentation for your operating system.
- Install Docker, see the Docker documentation for your operating system.
Once you have Poetry and Docker installed you can run the following commands (in the root of the repository) to install all other development dependencies in an isolated Python virtual environment:
To either stop or destroy the development environment use the following options.
- invoke stop - Stop the containers, but keep all underlying systems intact
- invoke destroy - Stop and remove all containers, volumes, etc. (This results in data loss due to the volume being deleted)
Local Poetry Development Environment¶
- Create an
invoke.ymlfile with the following contents at the root of the repo and edit as necessary
Run the following commands:
If you want to develop on the latest develop branch of Nautobot, run the following command:
poetry add --optional git+https://github.com/nautobot/nautobot@develop. After the
@ symbol must match either a branch or a tag.
You can now run
nautobot-server commands as you would from the Nautobot documentation for example to start the development server:
Nautobot server can now be accessed at http://localhost:8080.
It is typically recommended to launch the Nautobot runserver command in a separate shell so you can keep developing and manage the webserver separately.
Updating the Documentation¶
Documentation dependencies are pinned to exact versions to ensure consistent results. For the development environment, they are defined in the
If you need to update any of the documentation dependencies to a newer version, make sure you copy the exact same versions pinned in
pyproject.toml to the
docs/requirements.txt file as well. The latter is used in the automated build pipeline on ReadTheDocs to build the live version of the documentation.
CLI Helper Commands¶
The project features a CLI helper based on Invoke to help setup the development environment. The commands are listed below in 3 categories:
Each command can be executed with
invoke <command>. All commands support the arguments
--python-ver if you want to manually define the version of Python and Nautobot to use. Each command also has its own help
invoke <command> --help
To run the mysql (mariadb) development environment, set the environment variable as such
Local Development Environment¶
bandit Run bandit to validate basic static code security analysis. black Run black to check that Python files adhere to its style standards. flake8 Run flake8 to check that Python files adhere to its style standards. pydocstyle Run pydocstyle to validate docstring formatting adheres to NTC defined standards. pylint Run pylint code analysis. tests Run all tests for this plugin. unittest Run Django unit tests for the plugin.
This project provides the ability to develop and manage the Nautobot server locally (with supporting services being Dockerized) or by using only Docker containers to manage Nautobot. The main difference between the two environments is the ability to debug and use pdb when developing locally. Debugging with pdb within the Docker container is more complicated, but can still be accomplished by either entering into the container (via
docker exec) or attaching your IDE to the container and running the Nautobot service manually within the container.
The upside to having the Nautobot service handled by Docker rather than locally is that you do not have to manage the Nautobot server. The Docker logs provide the majority of the information you will need to help troubleshoot, while getting started quickly and not requiring you to perform several manual steps and remembering to have the Nautobot server running in a separate terminal while you develop.
The local environment still uses Docker containers for the supporting services (Postgres, Redis, and RQ Worker), but the Nautobot server is handled locally by you, the developer.
Follow the directions below for the specific development environment that you choose.
Poetry is used in lieu of the "virtualenv" commands and is leveraged in both environments. The virtual environment will provide all of the Python packages required to manage the development environment such as Invoke. See the Local Development Environment section to see how to install Nautobot if you're going to be developing locally (i.e. not using the Docker container).
pyproject.toml file outlines all of the relevant dependencies for the project:
tool.poetry.dependencies- the main list of dependencies.
tool.poetry.dev-dependencies- development dependencies, to facilitate linting, testing, and documentation building.
poetry shell command is used to create and enable a virtual environment managed by Poetry, so all commands ran going forward are executed within the virtual environment. This is similar to running the
source venv/bin/activate command with virtualenvs. To install project dependencies in the virtual environment, you should run
poetry install - this will install both project and development dependencies.
For more details about Poetry and its commands please check out its online documentation.
Full Docker Development Environment¶
This project is set up with a number of Invoke tasks consumed as simple CLI commands to get developing fast. You'll use a few
invoke commands to get your environment up and running.
Copy the credentials file for Nautobot¶
First, you need to create the
development/creds.env file - it stores a bunch of private information such as passwords and tokens for your local Nautobot install. You can make a copy of the
development/creds.example.env and modify it to suit you.
Invoke - Building the Docker Image¶
The first thing you need to do is build the necessary Docker image for Nautobot that installs the specific
nautobot_ver. The image is used for Nautobot and the Celery worker service used by Docker Compose.
➜ invoke build ... <omitted for brevity> #14 exporting to image #14 sha256:e8c613e07b0b7ff33893b694f7759a10d42e180f2b4dc349fb57dc6b71dcab00 #14 exporting layers #14 exporting layers 1.2s done #14 writing image sha256:2d524bc1665327faa0d34001b0a9d2ccf450612bf8feeb969312e96a2d3e3503 done #14 naming to docker.io/nautobot-device-lifecycle-mgmt/nautobot:latest-py3.7 done
Invoke - Starting the Development Environment¶
Next, you need to start up your Docker containers.
➜ invoke start Starting Nautobot in detached mode... Running docker-compose command "up --detach" Creating network "nautobot_device_lifecycle_mgmt_default" with the default driver Creating volume "nautobot_device_lifecycle_mgmt_postgres_data" with default driver Creating nautobot_device_lifecycle_mgmt_redis_1 ... Creating nautobot_device_lifecycle_mgmt_docs_1 ... Creating nautobot_device_lifecycle_mgmt_postgres_1 ... Creating nautobot_device_lifecycle_mgmt_postgres_1 ... done Creating nautobot_device_lifecycle_mgmt_redis_1 ... done Creating nautobot_device_lifecycle_mgmt_nautobot_1 ... Creating nautobot_device_lifecycle_mgmt_docs_1 ... done Creating nautobot_device_lifecycle_mgmt_nautobot_1 ... done Creating nautobot_device_lifecycle_mgmt_worker_1 ... Creating nautobot_device_lifecycle_mgmt_worker_1 ... done Docker Compose is now in the Docker CLI, try `docker compose up`
This will start all of the Docker containers used for hosting Nautobot. You should see the following containers running after
invoke start is finished.
➜ docker ps ****CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES ee90fbfabd77 nautobot-device-lifecycle-mgmt/nautobot:latest-py3.7 "nautobot-server rqw…" 16 seconds ago Up 13 seconds nautobot_device_lifecycle_mgmt_worker_1 b8adb781d013 nautobot-device-lifecycle-mgmt/nautobot:latest-py3.7 "/docker-entrypoint.…" 20 seconds ago Up 15 seconds 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp nautobot_device_lifecycle_mgmt_nautobot_1 d64ebd60675d nautobot-device-lifecycle-mgmt/nautobot:latest-py3.7 "mkdocs serve -v -a …" 25 seconds ago Up 18 seconds 0.0.0.0:8001->8080/tcp, :::8001->8080/tcp nautobot_device_lifecycle_mgmt_docs_1 e72d63129b36 postgres:13-alpine "docker-entrypoint.s…" 25 seconds ago Up 19 seconds 0.0.0.0:5432->5432/tcp, :::5432->5432/tcp nautobot_device_lifecycle_mgmt_postgres_1 96c6ff66997c redis:6-alpine "docker-entrypoint.s…" 25 seconds ago Up 21 seconds 0.0.0.0:6379->6379/tcp, :::6379->6379/tcp nautobot_device_lifecycle_mgmt_redis_1
Once the containers are fully up, you should be able to open up a web browser, and view:
- The Nautobot homepage at http://localhost:8080
- A live version of the documentation at http://localhost:8001
Sometimes the containers take a minute to fully spin up. If the page doesn't load right away, wait a minute and try again.
Invoke - Creating a Superuser¶
The Nautobot development image will automatically provision a super user when specifying the following variables within
creds.env which is the default when copying
The default username is admin, but can be overridden by specifying NAUTOBOT_SUPERUSER_USERNAME.
If you need to create additional superusers, run the follow commands.
➜ invoke createsuperuser Running docker-compose command "ps --services --filter status=running" Running docker-compose command "exec nautobot nautobot-server createsuperuser --username admin" Error: That username is already taken. Username: ntc Email address: firstname.lastname@example.org Password: Password (again): Superuser created successfully.
Invoke - Stopping the Development Environment¶
The last command to know for now is
➜ invoke stop Stopping Nautobot... Running docker-compose command "down" Stopping nautobot_device_lifecycle_mgmt_worker_1 ... Stopping nautobot_device_lifecycle_mgmt_nautobot_1 ... Stopping nautobot_device_lifecycle_mgmt_docs_1 ... Stopping nautobot_device_lifecycle_mgmt_redis_1 ... Stopping nautobot_device_lifecycle_mgmt_postgres_1 ... Stopping nautobot_device_lifecycle_mgmt_worker_1 ... done Stopping nautobot_device_lifecycle_mgmt_nautobot_1 ... done Stopping nautobot_device_lifecycle_mgmt_postgres_1 ... done Stopping nautobot_device_lifecycle_mgmt_redis_1 ... done Stopping nautobot_device_lifecycle_mgmt_docs_1 ... done Removing nautobot_device_lifecycle_mgmt_worker_1 ... Removing nautobot_device_lifecycle_mgmt_nautobot_1 ... Removing nautobot_device_lifecycle_mgmt_docs_1 ... Removing nautobot_device_lifecycle_mgmt_redis_1 ... Removing nautobot_device_lifecycle_mgmt_postgres_1 ... Removing nautobot_device_lifecycle_mgmt_postgres_1 ... done Removing nautobot_device_lifecycle_mgmt_docs_1 ... done Removing nautobot_device_lifecycle_mgmt_worker_1 ... done Removing nautobot_device_lifecycle_mgmt_redis_1 ... done Removing nautobot_device_lifecycle_mgmt_nautobot_1 ... done Removing network nautobot_device_lifecycle_mgmt_default
This will safely shut down all of your running Docker containers for this project. When you are ready to spin containers back up, it is as simple as running
invoke start again as seen previously.
If you're wanting to reset the database and configuration settings, you can use the
invoke destroy command, but you will lose any data stored in those containers, so make sure that is what you want to do.
Real-Time Updates? How Cool!¶
Your environment should now be fully setup, all necessary Docker containers are created and running, and you're logged into Nautobot in your web browser. Now what?
Now you can start developing your plugin in the project folder!
The magic here is the root directory is mounted inside your Docker containers when built and ran, so any changes made to the files in here are directly updated to the Nautobot plugin code running in Docker. This means that as you modify the code in your plugin folder, the changes will be instantly updated in Nautobot.
There are a few exceptions to this, as outlined in the section To Rebuild or Not To Rebuild.
The back-end Django process is setup to automatically reload itself (it only takes a couple of seconds) every time a file is updated (saved). So for example, if you were to update one of the files like
tables.py, then save it, the changes will be visible right away in the web browser!
You may get connection refused while Django reloads, but it should be refreshed fairly quickly.
When trying to debug an issue, one helpful thing you can look at are the logs within the Docker containers.
-f tag will keep the logs open, and output them in realtime as they are generated.
So for example, our plugin is named
nautobot-device-lifecycle-mgmt, the command would most likely be
docker logs nautobot_device_lifecycle_mgmt_nautobot_1 -f. You can find the name of all running containers via
If you want to view the logs specific to the worker container, simply use the name of that container instead.
To Rebuild or Not to Rebuild¶
Most of the time, you will not need to rebuild your images. Simply running
invoke start and
invoke stop is enough to keep your environment going.
However there are a couple of instances when you will want to.
Updating Environment Variables¶
To add environment variables to your containers, thus allowing Nautobot to use them, you will update/add them in the
development/development.env file. However, doing so is considered updating the underlying container shell, instead of Django (which auto restarts itself on changes).
To get new environment variables to take effect, you will need stop any running images, rebuild the images, then restart them. This can easily be done with 3 commands:
Once completed, the new/updated environment variables should now be live.
Installing Additional Python Packages¶
If you want your plugin to leverage another available Nautobot plugin or another Python package, you can easily add them into your Docker environment.
Once the dependencies are resolved, stop the existing containers, rebuild the Docker image, and then start all containers again.
Installing Additional Nautobot Plugins¶
Let's say for example you want the new plugin you're creating to integrate into Slack. To do this, you will want to integrate into the existing Nautobot ChatOps Plugin.
Once you activate the virtual environment via Poetry, you then tell Poetry to install the new plugin.
Before you continue, you'll need to update the file
development/nautobot_config.py accordingly with the name of the new plugin under
PLUGINS and any relevant settings as necessary for the plugin under
PLUGINS_CONFIG. Since you're modifying the underlying OS (not just Django files), you need to rebuild the image. This is a similar process to updating environment variables, which was explained earlier.
Once the containers are up and running, you should now see the new plugin installed in your Nautobot instance.
You can even launch an
ngrok service locally on your laptop, pointing to port 8080 (such as for chatops development), and it will point traffic directly to your Docker images.
Updating Python Version¶
To update the Python version, you can update it within
Or set the
Updating Nautobot Version¶
To update the Nautobot version, you can update it within
Or set the
Other Miscellaneous Commands To Know¶
To drop into a Django shell for Nautobot (in the Docker container) run:
This is the same as running:
iPython Shell Plus¶
Django also has a more advanced shell that uses iPython and that will automatically import all the models:
This is the same as running:
To run tests against your code, you can run all of the tests that TravisCI runs against any new PR with:
To run an individual test, you can run any or all of the following: