lae.netbox

Przegląd Wersje Wgląd

:rola-autor: lae :rola-nazwa: netbox :rola: {rola-autor}.{rola-nazwa} :nazwa-gh: {rola-autor}/ansible-role-{rola-nazwa} :wersja-netbox: 3.7.3 = {rola} :spis-treści: :miejsce-spisu-treści: wstęp ifdef::env-github[] :tytuł-wskazówki: :bulb: :tytuł-ostrzeżenia: :warning: endif::[]

ifdef::env-github[] image:https://img.shields.io/badge/rola-{rola}-blue?style=for-the-badge[Ansible Galaxy Role,link=https://galaxy.ansible.com/{rola-autor}/{rola-nazwa}] endif::env-github[]

Zainstalowuje i konfiguruje https://github.com/netbox-community/netbox[NetBox], narzędzie do zarządzania adresami IP (IPAM) oraz infrastrukturą centrum danych (DCIM).

Ta rola zainstaluje NetBox w własnym virtualenv, używając tarballa lub git, z uWSGI jako serwerem aplikacji.

Obsługuje CentOS 7,8 / RHEL 9 / Debian 9,10,11,12 / Ubuntu 16, 18, 20 i 22.

Należy pamiętać, że ta rola jest nieco zdefiniowana i różni się od instrukcji instalacji podanych w dokumentacji NetBox. Główne różnice to:

  • Używa systemd dostarczonego przez dystrybucję zamiast supervisord
  • Wykorzystuje uWSGI jako serwer aplikacji zamiast gunicorn
  • Zabezpiecza usługę NetBox/uWSGI (zobacz templates/netbox.service.j2)
  • Będzie działać na gorąco przy aktualizacjach i zmianach konfiguracji

== Szybkie rozpoczęcie

Pod warunkiem, że masz zainstalowany Ansible i korzystasz z domyślnych ustawień:

[source,bash,subs="attributes"]

ansible-galaxy install geerlingguy.postgresql davidwittman.redis {rola} ansible-galaxy collection install community.postgresql ansible-playbook -i twoj.serwer.fqdn, ~/.ansible/roles/{rola}/examples/playbook_single_host_deploy.yml -K

To zainstaluje NetBox i PostgreSQL na twoj.serwer.fqdn; po zakończeniu powinno być dostępne na porcie 80. Zmodyfikuj, jeśli to konieczne. Czytaj dalej, aby uzyskać więcej informacji.

Możesz również użyć Vagrant, jeśli wolisz, aby uruchomić NetBox na localhost:8080:

[source,bash,subs="attributes"]

ansible-galaxy install geerlingguy.postgresql davidwittman.redis {rola} ansible-galaxy collection install community.postgresql cd ~/.ansible/roles/{rola}/ vagrant up

== Wsparcie / Wkład

Jeśli chciałbyś przyczynić się do tej roli, zapoznaj się z DEVELOPING.md, aby poznać proces pracy oraz (opcjonalnie) instrukcje dotyczące konfiguracji środowiska deweloperskiego. Ta rola korzysta z lae.travis-lxc podczas testowania pod Travis CI, co możesz znaleźć w katalogu tests/.

ifeval::["{rola-autor}" == "lae"] Jeśli potrzebujesz wsparcia lub chcesz przyczynić się do tej roli, ale potrzebujesz wskazówek, śmiało pytaj na serwerze Discord @lae: https://discord.gg/cjqr6Fg endif::[] == Wymagania wstępne

=== PostgreSQL

Ta rola nie instaluje serwera PostgreSQL (ale stworzy bazę danych, jeśli będzie to konieczne), więc musisz zainstalować serwer PostgreSQL oraz stworzyć użytkownika bazy danych oddzielnie od tej roli. Zobacz sekcję Przykładowy playbook.

Ponadto, dla Ansible 2.10+, możesz potrzebować zainstalować kolekcję community.postgresql. Zaleca się określenie tego w pliku requirements.yml twojego playbooka. Na przykład:

[source,yaml]

collections:

  • name: community.postgresql version: 3.4.0

OSTRZEŻENIE: NetBox w wersji v2.2.0+ wymaga co najmniej PostgreSQL 9.4, co może być niedostępne w repozytoriach twojej dystrybucji. Możesz chcieć użyć roli do tego zadania.

=== Redis

Ta rola nie instaluje ani nie zarządza instancją Redis. Możesz chcieć zainstalować redis-server poprzez zadanie w pre_tasks w swoim playbooku lub użyć roli do instalacji Redis, takiej jak https://galaxy.ansible.com/davidwittman/redis[DavidWittman.redis].

OSTRZEŻENIE: NetBox w wersji v2.9.0+ wymaga co najmniej Redis 4.0. Sugerowana powyżej rola domyślnie ustawiona jest na wersję 2.8, więc upewnij się, że określisz nowszą wersję w zmiennej roli lub zainstaluj Redis 4.0+ inną metodą.

== Zmienne roli

WSKAZÓWKA: Zobacz examples/ po przykładowe playbooki, które możesz napisać dla różnych scenariuszy.

OSTRZEŻENIE: Kilka zmiennych roli jest obowiązkowych. Szukaj poniżej pogrubionej wymaganej.

[source,yaml]

netbox_stable: false netbox_git: false

Obowiązkowe jest ustawienie jednej z powyższych zmiennych na true. netbox_stable informuje rolę, że ma zainstalować poprzez wydobycie tarballi z GitHub, podczas gdy netbox_git mówi roli, aby sklonować repozytorium NetBox git - są one wzajemnie wykluczające się.

[source,yaml,subs="attributes"]

netbox_stable_version: {wersja-netbox} netbox_stable_uri: "https://github.com/netbox-community/netbox/archive/v{{ netbox_stable_version }}.tar.gz"

Te zmienne można skonfigurować, aby przypiąć wersję (np. inkrementacja spowoduje aktualizację) lub zainstalować przy użyciu tarballa znajdującego się gdzie indziej. Przydatne, gdy musisz zmodyfikować coś w wersji lub gdy instalujesz lokalnie za zaporą.

[source,yaml]

netbox_git_version: develop netbox_git_uri: "https://github.com/netbox-community/netbox.git"

netbox_git_version może być dowolnym ważnym odniesieniem w repozytorium git. netbox_git_uri można użyć do wskazania na przykład lokalnego repozytorium lub fork.

[source,yaml]

netbox_superuser_enabled: true netbox_superuser_username: admin #netbox_superuser_password: changeme netbox_superuser_email: admin@localhost netbox_superuser_create_token: false

Te zmienne są używane do skonfigurowania lokalnego konta superużytkownika. Wyłącz to, jeśli nie chcesz go tworzyć (np. przy użyciu LDAP - chociaż posiadanie lokalnego superużytkownika może być wciąż korzystne w takim przypadku). Gdy jest włączone, należy ustawić hasło dla superużytkownika. Ta rola stworzy nowego superużytkownika, jeśli użytkownik nie istnieje, lub zmodyfikuje istniejącego użytkownika, jeśli nie jest superużytkownikiem/ma inną email lub hasło. (Tak, możesz użyć tego do zresetowania hasła swojego superużytkownika, jeśli je zapomnisz). netbox_superuser_create_token można użyć do wygenerowania losowego tokena API dla superużytkownika, jeśli będzie to potrzebne.

[source,yaml]

netbox_database: netbox netbox_database_user: netbox #netbox_database_password: changeme #netbox_database_host: localhost netbox_database_port: 5432 #netbox_database_socket: /var/run/postgresql

Obowiązkowe jest skonfigurowanie albo katalogu gniazda (do komunikacji przez UNIX socket), albo hosta/hasła (do użycia TCP/IP). Zobacz sekcję Przykładowy playbook dla dodatkowych informacji o konfiguracji bazy danych.

Należy pamiętać, że te zmienne są używane do skonfigurowania DATABASE w configuration.py.

[source,yaml]

netbox_database_conn_age: 300

Aby skonfigurować NetBox tak, aby utrzymywał otwarte połączenia z bazą danych dłużej niż podczas jednego żądania, ustaw netbox_database_conn_age na preferowany maksymalny wiek połączenia w sekundach. 300 sekund (5 minut) to zazwyczaj dobry czas na początek.

[source,yaml]

netbox_database_maintenance: postgres

Jeśli baza danych postgres jest skonfigurowana tak, aby ograniczyć dostęp do konkretnych tabel bazy danych dla użytkownika skonfigurowanego z Netbox, możesz ustawić netbox_database_maintenance, aby zastąpić domyślną bazę danych używaną do sprawdzania połączenia, na inną tabelę niż domyślna postgres. Domyślnie jest to pusty tabela w każdej bazie danych postgres, ale niektóre konfiguracje mogą blokować dostęp do tej tabeli, więc można tu użyć innej tabeli (np. netbox_prod).

[source,yaml]

Przykładowe użycie, domyślnie jest to pusty słownik

netbox_database_options: sslmode: require isolation_level: 3

Jeśli musisz ustawić inne parametry PostgreSQL, możesz to zrobić tutaj. W przypadkach takich jak https://docs.djangoproject.com/en/3.1/ref/databases/#isolation-level[poziomy izolacji] należy użyć numerycznej wartości, a nie stałej: psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE vs 3. Dodawaj tu tylko rzeczy, jeśli naprawdę wiesz, co robisz.

[source,yaml]

netbox_redis_host: 127.0.0.1 netbox_redis_port: 6379 netbox_redis_password: '' netbox_redis_database: 0 netbox_redis_default_timeout: 300 netbox_redis_ssl_enabled: false netbox_redis_insecure_skip_tls_verify: false

netbox_redis_cache_host: "{{ netbox_redis_host }}" netbox_redis_cache_port: "{{ netbox_redis_port }}" netbox_redis_cache_database: 1 netbox_redis_cache_password: "{{ netbox_redis_password }}" netbox_redis_cache_default_timeout: "{{ netbox_redis_default_timeout }}" netbox_redis_cache_ssl_enabled: "{{ netbox_redis_ssl_enabled }}" netbox_redis_cache_insecure_skip_tls_verify: "{{ netbox_redis_insecure_skip_tls_verify }}"

To wypełnia słownik REDIS w configuration.py. Użyj drugiego zbioru zmiennych, jeśli chcesz oddzielić swoją bazę danych cache od bazy danych webhooków.

[source,yaml]

netbox_redis_sentinels:

  • { host: '192.168.0.1', port: '5000' },
  • { host: '192.168.0.2', port: '5000' } netbox_redis_sentinel_service: 'netbox' netbox_redis_password: '' netbox_redis_database: 0 netbox_redis_default_timeout: 300 netbox_redis_ssl_enabled: false

netbox_redis_cache_sentinels: "{{ netbox_redis_sentinels }}" netbox_redis_cache_sentinel_service: "{{ netbox_redis_sentinel_service }}" netbox_redis_cache_database: 1 netbox_redis_cache_password: "{{ netbox_redis_password }}" netbox_redis_cache_default_timeout: "{{ netbox_redis_default_timeout }}" netbox_redis_cache_ssl_enabled: "{{ netbox_redis_ssl_enabled }}"

Użyj tej składni, jeśli twoja instalacja Redis korzysta z architektury sentinel (wielonodowej). Użyj drugiego zbioru zmiennych, jeśli chcesz oddzielić swoją bazę danych cache od bazy danych webhooków.

[source,yaml]

netbox_rqworker_processes: 1

Określ, ile procesów roboczych kolejek żądań powinno zostać uruchomionych przez usługę systemd. Możesz to zostawić na domyślnej wartości 1, chyba że masz dużą liczbę raportów, skryptów lub innych zadań w tle.

[source,yaml]

netbox_config: #SECRET_KEY: ALLOWED_HOSTS: - localhost - 127.0.0.1 #NAPALM_USERNAME: #NAPALM_PASSWORD: MEDIA_ROOT: "{{ netbox_shared_path }}/media" REPORTS_ROOT: "{{ netbox_shared_path }}/reports" SCRIPTS_ROOT: "{{ netbox_shared_path }}/scripts"

To słownik ustawień wykorzystywanych do szablonowania configuration.py NetBox. Zobacz http://netbox.readthedocs.io/en/stable/configuration/mandatory-settings/[Ustawienia obowiązkowe] i http://netbox.readthedocs.io/en/stable/configuration/optional-settings/[Ustawienia opcjonalne] w dokumentacji NetBox, aby uzyskać więcej szczegółów, a także examples/netbox_config.yml w tym repozytorium.

Nie ma potrzeby definiować SECRET_KEY tutaj - ta rola automatycznie utworzy jeden dla ciebie w {{ netbox_shared_path }}/generated_secret_key. SECRET_KEY będzie następnie odczytywane z tego pliku przy kolejnych uruchomieniach, chyba że później ustawisz to w swoim playbooku. Należy pamiętać, aby zdefiniować SECRET_KEY, jeśli wdrażasz wiele instancji NetBox za jednym balansującym obciążenia.

Jeśli włączyłeś integrację z NAPALM w tej roli, będziesz musiał skonfigurować również dane uwierzytelniające NAPALM tutaj.

MEDIA_ROOT/REPORTS_ROOT/SCRIPTS_ROOT, chociaż nie są obowiązkowe w dokumentacji NetBox, są obowiązkowe w tej roli, aby zapobiec utracie tych plików podczas aktualizacji (ta rola nie aktualizuje NetBox w miejscu). Powinny być ustawione na katalog, który jest stały i nie jest tracony podczas aktualizacji (domyślna, podana powyżej, może być używana bez problemów). Ta rola spróbuje utworzyć te katalogi i zmienić ich właściciela na to, co jest ustawione w netbox_user.

[source,yaml]

netbox_scripts: [] netbox_reports: []

https://netbox.readthedocs.io/en/stable/additional-features/custom-scripts/[Skrypty] i https://netbox.readthedocs.io/en/stable/additional-features/reports/[Raporty] do przesłania do użycia w NetBoxie. Powinny to być listy słowników z atrybutem src, określającym lokalną ścieżkę do skryptu lub raportu, oraz atrybutem name, określającym nazwę modułu (nazwa skryptu/raportu). Na przykład:

[source,yaml]

Przykład

netbox_scripts:

  • src: netbox_scripts/migrate_application.py name: migrate_application netbox_reports:
  • src: netbox_reports/devices.py name: devices

To skopiuje netbox_scripts/migrate_application.py z katalogu twojego playbooka do {{ netbox_config.SCRIPTS_ROOT }}/migrate_application.py oraz netbox_reports/devices.py do {{ netbox.config.REPORTS_ROOT }}/devices.py.

[source,yaml]

netbox_pip_packages: []

Przykład:

netbox_pip_packages:

To lista dodatkowych pakietów do zainstalowania przez pip w virtualenv NetBox. Możesz określić każdy ważny artefakt, który rozumie pip.

Jeśli wymieniasz tu jakiekolwiek wtyczki, nie zapomnij uwzględnić odpowiednich konfiguracji wtyczek w zmiennej roli netbox_config. Przeczytaj https://netbox.readthedocs.io/en/stable/plugins/[Wtyczki], aby uzyskać więcej informacji.

[source,yaml]

netbox_user: netbox netbox_group: netbox netbox_home: /srv/netbox netbox_releases_path: "{{ netbox_home }}/releases" netbox_git_repo_path: "{{ netbox_releases_path }}/git-repo" netbox_git_deploy_path: "{{ netbox_releases_path }}/git-deploy" netbox_stable_path: "{{ netbox_releases_path }}/netbox-{{ netbox_stable_version }}" netbox_current_path: "{{ netbox_home }}/current" netbox_shared_path: "{{ netbox_home }}/shared"

To wszystkie szczegóły dotyczące wdrożenia, które można zmodyfikować, aby zmienić użytkownika aplikacji i lokalizacje przechowywania aplikacji. netbox_releases_path przechowuje wszystkie wydania NetBox, jakie kiedykolwiek wdrożyłeś. netbox_git_repo_path to miejsce, w którym zostanie sklonowane repozytorium Git i powinno pozostać nietknięte - natomiast netbox_git_deploy_path to miejsce, w którym zostanie wydobyty git archive przy użyciu odniesienia netbox_git_version. netbox_stable_path to folder wydobyty z tarballa. netbox_current_path będzie symlinkowane do wybranego wydania i używane w plikach usług/konfiguracji jako lokalizacja, w której zainstalowano NetBox. netbox_shared_path jest przeznaczone do przechowywania plików konfiguracyjnych i innej "wspólnej" zawartości, takich jak logi.

[source,yaml]

netbox_socket: "127.0.0.1:8000" netbox_protocol: http netbox_processes: "{{ ansible_processor_vcpus }}"

netbox_socket definiuje, do czego będzie bindowana usługa uWSGI i można go ustawić na dowolny ważny adres https://www.freedesktop.org/software/systemd/man/systemd.socket.html#ListenStream=[ListenStream] (socket systemd). Ustaw netbox_protocol na uwsgi, jeśli chcesz, aby uWSGI komunikowało się przez WSGI (na przykład, jeśli uruchamiasz nginx jako balancer obciążenia). netbox_processes określa, ile pracowników NetBox uWSGI uruchomi, aby obsługiwać żądania.

[source,yaml]

netbox_application_log: "file:{{ netbox_shared_path }}/application.log" netbox_requests_log: "file:{{ netbox_shared_path }}/requests.log"

To definiuje, gdzie będą przechowywane logi. Możesz użyć zewnętrznych narzędzi do logowania zamiast lokalnych plików, jeśli chcesz, http://uwsgi-docs.readthedocs.io/en/latest/Logging.html#pluggable-loggers[jeśli uWSGI to wspiera]. Logi aplikacji są powiązane z logger, a logi żądań z req-logger.

[source,yaml]

netbox_ldap_enabled: false netbox_ldap_config_template: netbox_ldap_config.py.j2

Przełącz netbox_ldap_enabled na true, aby skonfigurować autoryzację LDAP dla NetBox. netbox_ldap_config_template powinien być ścieżką do twojego szablonu - domyślnie Ansible będzie przeszukiwać katalog templates/ w twoim playbooku. Możesz znaleźć przykład w examples/. Będziesz także musiał ustawić netbox_config.REMOTE_AUTH_BACKEND na netbox.authentication.LDAPBackend.

WSKAZÓWKA: Domyślnie, lokalny (nie-LDAP) superużytkownik będzie nadal tworzony przez tę rolę. Jeśli to jest niepożądane, rozważ przełączenie netbox_superuser_enabled.

[source,yaml]

netbox_napalm_enabled: false netbox_napalm_packages:

  • napalm

Przełącz netbox_napalm_enabled na true, aby włączyć integrację z NAPALM w NetBox. Musisz zdefiniować NAPALM_USERNAME i NAPALM_PASSWORD w zmiennej netbox_config, aby móc korzystać z NAPALM. Dodaj dodatkowe biblioteki Python dla NAPALM, wymieniając je w netbox_napalm_packages (np. napalm-eos).

[source,yaml] netbox_metrics_enabled: false

Przełącz netbox_metrics_enabled na true, aby włączyć metryki aplikacji (przez https://github.com/korfuri/django-prometheus[django-prometheus]). Dodaje to odpowiednie elementy konfiguracji do prawidłowego przetwarzania metryk. (https://netbox.readthedocs.io/en/stable/additional-features/prometheus-metrics/[więcej informacji]).

[source,yaml]

netbox_metrics_dir: netbox_metrics netbox_metrics_path: "/run/{{ netbox_metrics_dir }}"

Nazwę katalogu, w którym przechowywane są pliki metryczne, można ustawić za pomocą netbox_metrics_dir. Jednak netbox_metrics_path musi pozostać na domyślnej wartości (podanej powyżej), aby działało z systemd i parametrem RuntimeDirectory (który wskazuje tylko na /run).

[source,yaml] netbox_keep_uwsgi_updated: false

Przełącz netbox_keep_uwsgi_updated na true, jeśli chcesz, aby twój serwer uwsgi był w najnowszej wersji, w przeciwnym razie uwsgi nie będzie aktualizowane przy kolejnych uruchomieniach twojego playbooka.

[source,yaml] netbox_uwsgi_options: {}

Określ dodatkowe opcje konfiguracyjne do dodania do uwsgi.ini tutaj. Mnożnik ten powinien być słownikiem par klucz/wartość, np. buffer-size: 65535.

[source,yaml] netbox_uwsgi_in_venv: false

Przełącz netbox_uwsgi_in_venv na true, jeśli chcesz, aby uwsgi było zainstalowane w tym samym wirtualnym środowisku, co NetBox. W przeciwnym razie, zostanie zainstalowane systemowo w ścieżce biblioteki wersji Pythona używanej do stworzenia wirtualnego środowiska (normalne/zwyczajne zachowanie).

OSTRZEŻENIE: Istnieje możliwość, że może to stać się domyślną opcją w późniejszej wersji tej roli (myślę, że po dalszym testowaniu między platformami). Zobacz https://github.com/lae/ansible-role-netbox/issues/144[issue #144] do dalszych szczegółów.

[source,yaml] netbox_install_epel: true

Przełącz netbox_install_epel na false, jeśli nie chcesz, aby ta rola zainstalowała dla ciebie Fedora EPEL. Może być to przydatne w środowiskach korporacyjnych, gdzie repozytoria systemowe są zarządzane/mirrorowane przez przedsiębiorstwo.

[source,yaml]

netbox_packages: [] netbox_python_packages: [] netbox_python_binary: /usr/bin/python{{ jakaś wersja }} netbox_ldap_packages: []

Te zmienne są dynamicznie generowane w zależności od docelowej dystrybucji. Możesz sprawdzić domyślne wartości poniżej katalogu vars/. Możesz używać tych zmiennych, aby celować w niespełniającą wymagań operacyjną (chociaż możesz otworzyć PR, aby dodać wsparcie!) lub aby wskazać niestandardowy interpreter Pythona (takiego jak PyPy) do użycia przy wdrażaniu. Należy jednak pamiętać, że wsparcie przez tę rolę może być ograniczone dla alternatywnych instalacji Pythona.

== Przykładowy playbook

Poniższy przykład instaluje PostgreSQL i tworzy użytkownika z solidną rolą Postgresa @geerlingguy, a następnie przystępuje do wdrożenia i skonfigurowania NetBox, używając lokalnego gniazda unix do komunikacji z serwerem Postgresa za pomocą domyślnego użytkownika bazy danych netbox.

[source,yaml,subs="attributes"]

  • hosts: netbox.idolactiviti.es become: yes roles:
    • geerlingguy.postgresql
    • davidwittman.redis
    • {rola} vars: netbox_stable: true netbox_database_socket: "{{ postgresql_unix_socket_directories[0] }}" netbox_superuser_password: netbox netbox_socket: "0.0.0.0:80" netbox_config: ALLOWED_HOSTS:
      • netbox.idolactiviti.es MEDIA_ROOT: "{{ netbox_shared_path }}/media" REPORTS_ROOT: "{{ netbox_shared_path }}/reports" SCRIPTS_ROOT: "{{ netbox_shared_path }}/scripts" postgresql_users:
      • name: "{{ netbox_database_user }}" role_attr_flags: CREATEDB,NOSUPERUSER redis_bind: 127.0.0.1 redis_version: 6.0.9 redis_checksum: sha256:dc2bdcf81c620e9f09cfd12e85d3bc631c897b2db7a55218fd8a65eaa37f86dd

Zauważ atrybut CREATEDB.

Zakładając, że masz już działający serwer PG z użytkownikiem netbox_prod_user stworzonym, który posiada bazę danych o nazwie netbox_prod, i pozwala hostowi, na którym instalujesz NetBox, na autoryzację przez TCP:

[source,yaml,subs="attributes"]

  • hosts: netbox.idolactiviti.es become: yes roles:
    • davidwittman.redis
    • {rola} vars: netbox_stable: true netbox_superuser_password: netbox netbox_socket: "0.0.0.0:80" netbox_config: ALLOWED_HOSTS:
      • "{{ inventory_hostname }}" MEDIA_ROOT: "{{ netbox_shared_path }}/media" REPORTS_ROOT: "{{ netbox_shared_path }}/reports" SCRIPTS_ROOT: "{{ netbox_shared_path }}/scripts" netbox_database_host: pg-netbox.idolactiviti.es netbox_database_port: 15432 netbox_database: netbox_prod netbox_database_user: netbox_prod_user netbox_database_password: "very_secure_password_for_prod" netbox_database_maintenance: netbox_prod redis_bind: 127.0.0.1 redis_version: 6.0.9 redis_checksum: sha256:dc2bdcf81c620e9f09cfd12e85d3bc631c897b2db7a55218fd8a65eaa37f86dd

Zobacz katalog examples/ dla więcej przykładów.

== Rozwiązywanie problemów

=== uWSGI resetowanie połączeń TCP Gdy netbox_protocol jest ustawione na http, uWSGI może wykazywać dziwne zachowanie i resetować połączenia TCP na pozór losowo. Może to objawiać się błędem "connection reset by peer", na przykład przy pracy z API używającym https://github.com/netbox-community/pynetbox[pynetbox]. Jeśli jesteś tym dotknięty, spróbuj zmienić netbox_protocol na uwsgi i użyć loadbalancera, lub dostosowując swoje netbox_uwsgi_options w sposób opisany poniżej. Zobacz https://github.com/lae/ansible-role-netbox/issues/130#issuecomment-847571006[ten problem na GitHubie] [source,yaml,subs="attributes"]

netbox_uwsgi_options: http-keepalive: "true" http-auto-chunked: "true" add-header: "Connection: Close"

O projekcie

Installs and configures NetBox, a DCIM suite, in a production setting.

role datacenter dcim ipam networking web
Zainstaluj
ansible-galaxy install lae.netbox
GitHub repozytorium
207 gwiazdki
72 forki
15 otwarte zgłoszenia
Licencja
mit
Pobrania
107.6k
Właściciel