Фильтр ipaddr

ipaddr() — это фильтр Jinja2, предназначенный для предоставления интерфейса к пакету Python netaddr внутри Ansible. Он может работать со строками или списками элементов, проверять различные данные на предмет того, являются ли они валидными IP-адресами, и манипулировать входными данными для извлечения запрошенной информации. ipaddr() работает как с адресами IPv4, так и с адресами IPv6 в различных форматах. Также доступны дополнительные функции для манипулирования IP-подсетями и MAC-адресами.

Чтобы использовать этот фильтр в Ansible, необходимо установить библиотеку Python netaddr на компьютере, на котором вы используете Ansible (она не требуется на удаленных хостах). Обычно она устанавливается с помощью системного менеджера пакетов или с помощью pip.

pip install netaddr

• Базовые тесты
• Фильтрация списков
• Оборачивание адресов IPv6 в скобки [ ]
• Базовые запросы
• Получение информации о хостах и сетях
• Получение информации из значений хост/префикс
• Преобразование масок подсетей в CIDR-запись
• Получение информации о сети в CIDR-записи
• Преобразование IP-адресов
• Преобразование IPv4-адреса в 6to4-адрес
• Поиск IP-адресов в диапазоне
• Проверка принадлежности адреса диапазону сети
• Математические операции с IP
• Манипулирование подсетями
• Объединение подсетей
• Фильтр MAC-адресов
• Генерация IPv6-адреса в режиме бессостоятельной конфигурации (SLAAC)

Базовые тесты

ipaddr() предназначен для возвращения входного значения, если запрос True, и False, если запрос False. Таким образом, его можно легко использовать в цепочке фильтров. Для использования фильтра, передайте строку:

{{ '192.0.2.0' | ansible.netcommon.ipaddr }}

Вы также можете передавать значения как переменные:

{{ myvar | ansible.netcommon.ipaddr }}

Вот результаты некоторых тестовых строк:

# These values are valid IP addresses or network ranges
'192.168.0.1'       -> 192.168.0.1
'192.168.32.0/24'   -> 192.168.32.0/24
'fe80::100/10'      -> fe80::100/10
45443646733         -> ::a:94a7:50d
'523454/24'         -> 0.7.252.190/24

# Values that are not valid IP addresses or network ranges
'localhost'         -> False
True                -> False
'space bar'         -> False
False               -> False
''                  -> False
':'                 -> False
'fe80:/10'          -> False

Иногда вам нужны либо IPv4, либо IPv6 адреса. Для фильтрации по конкретному типу, у фильтра ipaddr() есть два «псевдонима», ipv4() и ipv6().

Пример использования фильтра IPv4:

{{ myvar | ansible.netcommon.ipv4 }}

Аналогичный пример фильтра IPv6:

{{ myvar | ansible.netcommon.ipv6 }}

Вот результаты некоторых тестовых строк, отфильтрованных по IPv4:

'192.168.0.1'       -> 192.168.0.1
'192.168.32.0/24'   -> 192.168.32.0/24
'fe80::100/10'      -> False
45443646733         -> False
'523454/24'         -> 0.7.252.190/24

И те же данные, отфильтрованные по IPv6:

'192.168.0.1'       -> False
'192.168.32.0/24'   -> False
'fe80::100/10'      -> fe80::100/10
45443646733         -> ::a:94a7:50d
'523454/24'         -> False

Фильтрация списков

Вы можете фильтровать списки — ipaddr() вернет список со значениями, удовлетворяющими заданному запросу:

# Example list of values
test_list = ['192.24.2.1', 'host.fqdn', '::1', '192.168.32.0/24', 'fe80::100/10', True, '', '42540766412265424405338506004571095040/64']

# {{ test_list | ansible.netcommon.ipaddr }}
['192.24.2.1', '::1', '192.168.32.0/24', 'fe80::100/10', '2001:db8:32c:faad::/64']

# {{ test_list | ansible.netcommon.ipv4 }}
['192.24.2.1', '192.168.32.0/24']

# {{ test_list | ansible.netcommon.ipv6 }}
['::1', 'fe80::100/10', '2001:db8:32c:faad::/64']

Оборачивание адресов IPv6 в скобки [ ]

Некоторые конфигурационные файлы требуют, чтобы адреса IPv6 были «окружены» квадратными скобками ([ ]). Для этого можно использовать фильтр ipwrap(). Он будет оборачивать все адреса IPv6 и оставляет другие строки без изменений:

# {{ test_list | ansible.netcommon.ipwrap }}
['192.24.2.1', 'host.fqdn', '[::1]', '192.168.32.0/24', '[fe80::100]/10', True, '', '[2001:db8:32c:faad::]/64']

Как вы можете видеть, ipwrap() не отфильтровал значения, которые не являются IP-адресами, что обычно и нужно, когда, например, вы смешиваете IP-адреса с именами хостов. Если вам всё же нужно отфильтровать все значения, которые не являются IP-адресами, вы можете объединить оба фильтра:

# {{ test_list | ansible.netcommon.ipaddr | ansible.netcommon.ipwrap }}
['192.24.2.1', '[::1]', '192.168.32.0/24', '[fe80::100]/10', '[2001:db8:32c:faad::]/64']

Базовые запросы

Вы можете передать один аргумент в каждый фильтр ipaddr(). Фильтр будет обрабатывать его как запрос и возвращать значения, модифицированные этим запросом. Списки будут содержать только значения, которые вы ищете.

Типы запросов включают:

• запрос по имени: ansible.netcommon.ipaddr('address'), ansible.netcommon.ipv4('network');
• запрос по диапазону CIDR: ansible.netcommon.ipaddr('192.168.0.0/24'), ansible.netcommon.ipv6('2001:db8::/32');
• запрос по номеру индекса: ansible.netcommon.ipaddr('1'), ansible.netcommon.ipaddr('-1');

Если тип запроса не распознан, Ansible выдаст ошибку.

Получение информации о хостах и сетях

Вот наш тестовый список снова:

# Example list of values
test_list = ['192.24.2.1', 'host.fqdn', '::1', '192.168.32.0/24', 'fe80::100/10', True, '', '42540766412265424405338506004571095040/64']

Давайте возьмём список выше и получим только те элементы, которые являются IP-адресами хостов, а не диапазонами сетей:

# {{ test_list | ansible.netcommon.ipaddr('address') }}
['192.24.2.1', '::1', 'fe80::100']

Как вы видите, даже если некоторые значения содержали адрес хоста с префиксом CIDR, они были отброшены фильтром. Если вам нужны IP-адреса хостов с их правильными префиксами CIDR (как это обычно используется с адресацией IPv6), вы можете использовать фильтр ipaddr('host').

# {{ test_list | ansible.netcommon.ipaddr('host') }}
['192.24.2.1/32', '::1/128', 'fe80::100/10']

Фильтрация по типу IP-адреса также работает:

# {{ test_list | ansible.netcommon.ipv4('address') }}
['192.24.2.1']

# {{ test_list | ansible.netcommon.ipv6('address') }}
['::1', 'fe80::100']

Вы можете проверить доступность IP-адресов или диапазонов сетей в публичном интернете или в частных сетях:

# {{ test_list | ansible.netcommon.ipaddr('public') }}
['192.24.2.1', '2001:db8:32c:faad::/64']

# {{ test_list | ansible.netcommon.ipaddr('private') }}
['192.168.32.0/24', 'fe80::100/10']

Вы можете проверить, какие значения являются именно диапазонами сетей:

# {{ test_list | ansible.netcommon.ipaddr('net') }}
['192.168.32.0/24', '2001:db8:32c:faad::/64']

Вы также можете проверить, сколько IP-адресов может быть в определенном диапазоне:

# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('size') }}
[256, 18446744073709551616L]

Указав диапазон сети в качестве запроса, вы можете проверить, входит ли заданное значение в этот диапазон:

# {{ test_list | ansible.netcommon.ipaddr('192.0.0.0/8') }}
['192.24.2.1', '192.168.32.0/24']

Если вы укажете положительное или отрицательное целое число в качестве запроса, ipaddr() будет рассматривать это как индекс и вернет определённый IP-адрес из диапазона сетей в формате «хост/префикс»:

# First IP address (network address)
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('0') }}
['192.168.32.0/24', '2001:db8:32c:faad::/64']

# Second IP address (usually the gateway host)
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('1') }}
['192.168.32.1/24', '2001:db8:32c:faad::1/64']

# Last IP address (the broadcast address in IPv4 networks)
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('-1') }}
['192.168.32.255/24', '2001:db8:32c:faad:ffff:ffff:ffff:ffff/64']

Вы также можете выбирать IP-адреса из диапазона по их индексу, начиная или заканчивая диапазон:

# Returns from the start of the range
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('200') }}
['192.168.32.200/24', '2001:db8:32c:faad::c8/64']

# Returns from the end of the range
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('-200') }}
['192.168.32.56/24', '2001:db8:32c:faad:ffff:ffff:ffff:ff38/64']

# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('400') }}
['2001:db8:32c:faad::190/64']

Получение информации из значений хост/префикс

Вы часто используете комбинацию IP-адресов и префиксов подсети («CIDR»), это ещё более характерно для IPv6. Фильтр ansible.netcommon.ipaddr() может извлекать полезные данные из этих префиксов.

Вот пример набора из двух префиксов хоста (с некоторыми значениями «управления»):

host_prefix = ['2001:db8:deaf:be11::ef3/64', '192.0.2.48/24', '127.0.0.1', '192.168.0.0/16']

Сначала убедимся, что мы работаем только с корректными значениями хост/префикс, а не просто с подсетями или одиночными IP-адресами:

# {{ host_prefix | ansible.netcommon.ipaddr('host/prefix') }}
['2001:db8:deaf:be11::ef3/64', '192.0.2.48/24']

В системах на базе Debian конфигурация сети, хранящаяся в файле /etc/network/interfaces, использует сочетание IP-адреса, сетевого адреса, маски подсети и широковещательного адреса для настройки сетевого интерфейса IPv4. Мы можем получить эти значения из одной комбинации «хост/префикс»:

# Jinja2 template
{% set ipv4_host = host_prefix | unique | ansible.netcommon.ipv4('host/prefix') | first %}
iface eth0 inet static
    address   {{ ipv4_host | ansible.netcommon.ipaddr('address') }}
    network   {{ ipv4_host | ansible.netcommon.ipaddr('network') }}
    netmask   {{ ipv4_host | ansible.netcommon.ipaddr('netmask') }}
    broadcast {{ ipv4_host | ansible.netcommon.ipaddr('broadcast') }}

# Generated configuration file
iface eth0 inet static
    address   192.0.2.48
    network   192.0.2.0
    netmask   255.255.255.0
    broadcast 192.0.2.255

В приведенном выше примере нам нужно было учесть тот факт, что значения хранились в списке, что необычно для IPv4-сетей, где может быть задан только один IP-адрес на интерфейс. Однако IPv6-сети могут иметь несколько IP-адресов, заданных на интерфейсе:

# Jinja2 template
iface eth0 inet6 static
    {% set ipv6_list = host_prefix | unique | ansible.netcommon.ipv6('host/prefix') %}
    address {{ ipv6_list[0] }}
    {% if ipv6_list | length > 1 %}
    {% for subnet in ipv6_list[1:] %}
    up   /sbin/ip address add {{ subnet }} dev eth0
    down /sbin/ip address del {{ subnet }} dev eth0
    {% endfor %}
    {% endif %}

# Generated configuration file
iface eth0 inet6 static
    address 2001:db8:deaf:be11::ef3/64

При необходимости вы можете извлечь информацию о подсети и префиксе из значения «хост/префикс»:

# {{ host_prefix | ansible.netcommon.ipaddr('host/prefix') | ansible.netcommon.ipaddr('subnet') }}
['2001:db8:deaf:be11::/64', '192.0.2.0/24']

# {{ host_prefix | ansible.netcommon.ipaddr('host/prefix') | ansible.netcommon.ipaddr('prefix') }}
[64, 24]

Преобразование масок подсетей в CIDR-запись

Учитывая подсеть в виде сетевого адреса и маски подсети, фильтр ipaddr() может преобразовать её в CIDR-запись. Это может быть полезно для преобразования фактов Ansible, собранных о конфигурации сети, из масок подсети в формат CIDR:

ansible_default_ipv4: {
    address: "192.168.0.11",
    alias: "eth0",
    broadcast: "192.168.0.255",
    gateway: "192.168.0.1",
    interface: "eth0",
    macaddress: "fa:16:3e:c4:bd:89",
    mtu: 1500,
    netmask: "255.255.255.0",
    network: "192.168.0.0",
    type: "ether"
}

Сначала объедините сетевой адрес и маску подсети:

net_mask = "{{ ansible_default_ipv4.network }}/{{ ansible_default_ipv4.netmask }}"
'192.168.0.0/255.255.255.0'

Этот результат можно преобразовать в каноническую форму с помощью ipaddr(), чтобы получить подсеть в формате CIDR:

# {{ net_mask | ansible.netcommon.ipaddr('prefix') }}
'24'

# {{ net_mask | ansible.netcommon.ipaddr('net') }}
'192.168.0.0/24'

Получение информации о сети в CIDR-записи

Учитывая IP-адрес, фильтр ipaddr() может предоставить сетевой адрес в CIDR-записи. Это может быть полезно, когда вам нужно получить сетевой адрес из IP-адреса в формате CIDR.

Вот пример IP-адреса:

ip_address = "{{ ansible_default_ipv4.address }}/{{ ansible_default_ipv4.netmask }}"
'192.168.0.11/255.255.255.0'

Это можно использовать для получения сетевого адреса в формате CIDR:

# {{ ip_address | ansible.netcommon.ipaddr('network/prefix') }}
'192.168.0.0/24'

Преобразование IP-адресов

Вот наш тестовый список снова:

# Example list of values
test_list = ['192.24.2.1', 'host.fqdn', '::1', '192.168.32.0/24', 'fe80::100/10', True, '', '42540766412265424405338506004571095040/64']

Вы можете преобразовать IPv4-адреса в IPv6-адреса:

# {{ test_list | ansible.netcommon.ipv4('ipv6') }}
['::ffff:192.24.2.1/128', '::ffff:192.168.32.0/120']

Преобразование из IPv6 в IPv4 работает очень редко:

# {{ test_list | ansible.netcommon.ipv6('ipv4') }}
['0.0.0.1/32']

Но мы можем сделать двойное преобразование, если это необходимо:

# {{ test_list | ansible.netcommon.ipaddr('ipv6') | ansible.netcommon.ipaddr('ipv4') }}
['192.24.2.1/32', '0.0.0.1/32', '192.168.32.0/24']

Вы можете преобразовать IP-адреса в целые числа, точно так же, как вы можете преобразовать целые числа в IP-адреса:

# {{ test_list | ansible.netcommon.ipaddr('address') | ansible.netcommon.ipaddr('int') }}
[3222798849, 1, '3232243712/24', '338288524927261089654018896841347694848/10', '42540766412265424405338506004571095040/64']

Вы можете преобразовать IPv4-адрес в шестнадцатеричную запись с необязательным разделителем:

# {{ '192.168.1.5' | ansible.netcommon.ip4_hex }}
c0a80105
# {{ '192.168.1.5' | ansible.netcommon.ip4_hex(':') }}
c0:a8:01:05

Вы можете преобразовать IP-адреса в записи PTR:

# {% for address in test_list | ansible.netcommon.ipaddr %}
# {{ address | ansible.netcommon.ipaddr('revdns') }}
# {% endfor %}
1.2.24.192.in-addr.arpa.
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.
0.32.168.192.in-addr.arpa.
0.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.
0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.a.a.f.c.2.3.0.8.b.d.0.1.0.0.2.ip6.arpa.

Преобразование IPv4-адреса в 6to4-адрес

Туннель 6to4 — это способ доступа к интернету IPv6 из сети, поддерживающей только IPv4. Если у вас есть публичный IPv4-адрес, вы можете автоматически настроить его IPv6-эквивалент в диапазоне сети 2002::/16. После преобразования вы получите доступ к подсети 2002:xxxx:xxxx::/48, которая может быть разделена на 65535 /64 подсетей, если необходимо.

Для преобразования вашего IPv4-адреса просто отправьте его через фильтр '6to4'. Он будет автоматически преобразован в адрес маршрутизатора (с адресом хоста ::1/48):

# {{ '193.0.2.0' | ansible.netcommon.ipaddr('6to4') }}
2002:c100:0200::1/48

Поиск IP-адресов в диапазоне

Для поиска доступных IP-адресов в диапазоне IP попробуйте эти фильтры ipaddr.

Чтобы найти следующий доступный IP-адрес в диапазоне, используйте next_usable

# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('next_usable') }}
192.168.122.2

Чтобы найти последний доступный IP-адрес в диапазоне, используйте last_usable:

# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('last_usable') }}
192.168.122.254

Для поиска доступного диапазона IP-адресов от заданного сетевого адреса используйте range_usable:

# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('range_usable') }}
192.168.122.1-192.168.122.254

Чтобы найти IP-адрес пиринга для канала точка-точка, используйте peer:

# {{ '192.168.122.1/31' | ansible.netcommon.ipaddr('peer') }}
192.168.122.0
# {{ '192.168.122.1/30' | ansible.netcommon.ipaddr('peer') }}
192.168.122.2

Чтобы вернуть n-й IP-адрес из сети, используйте фильтр nthhost:

# {{ '10.0.0.0/8' | ansible.netcommon.nthhost(305) }}
10.0.1.49

nthhost также поддерживает отрицательное значение:

# {{ '10.0.0.0/8' | ansible.netcommon.nthhost(-1) }}
10.255.255.255

Чтобы найти следующий n-й доступный IP-адрес по отношению к другому в диапазоне, используйте next_nth_usable В примере next_nth_usable возвращает второй доступный IP-адрес для заданного диапазона IP-адресов:

# {{ '192.168.122.1/24' | ansible.netcommon.next_nth_usable(2) }}
192.168.122.3

Если доступного адреса нет, возвращается пустая строка:

# {{ '192.168.122.254/24' | ansible.netcommon.next_nth_usable(2) }}
""

Так же, как и next_nth_ansible, у вас есть previous_nth_usable для поиска предыдущего доступного адреса:

# {{ '192.168.122.10/24' | ansible.netcommon.previous_nth_usable(2) }}
192.168.122.8

Проверка, принадлежит ли адрес диапазону сети

Фильтр network_in_usable возвращает, является ли адрес, переданный в качестве аргумента, доступным в сети. Доступные адреса — это адреса, которые могут быть назначены хосту. Идентификатор сети и адрес широковещательной рассылки не являются доступными адресами.:

# {{ '192.168.0.0/24' | ansible.netcommon.network_in_usable( '192.168.0.1' ) }}
True

# {{ '192.168.0.0/24' | ansible.netcommon.network_in_usable( '192.168.0.255' ) }}
False

# {{ '192.168.0.0/16' | ansible.netcommon.network_in_usable( '192.168.0.255' ) }}
True

Фильтр network_in_network возвращает, находится ли адрес или сеть, переданные в качестве аргумента, в сети.:

# {{ '192.168.0.0/24' | ansible.netcommon.network_in_network( '192.168.0.1' ) }}
True

# {{ '192.168.0.0/24' | ansible.netcommon.network_in_network( '192.168.0.0/24' ) }}
True

# {{ '192.168.0.0/24' | ansible.netcommon.network_in_network( '192.168.0.255' ) }}
True

# Check in a network is part of another network
# {{ '192.168.0.0/16' | ansible.netcommon.network_in_network( '192.168.0.0/24' ) }}
True

Чтобы проверить, принадлежат ли несколько адресов одной сети, используйте фильтр reduce_on_network:

# {{ ['192.168.0.34', '10.3.0.3', '192.168.2.34'] | ansible.netcommon.reduce_on_network( '192.168.0.0/24' ) }}
['192.168.0.34']

Арифметика IP-адресов

Фильтр ipmath() можно использовать для выполнения простых математических операций с IP-адресами.

Вот несколько простых примеров:

# Get the next five addresses based on an IP address
# {{ '192.168.1.5' | ansible.netcommon.ipmath(5) }}
192.168.1.10

# Get the ten previous addresses based on an IP address
# {{ '192.168.0.5' | ansible.netcommon.ipmath(-10) }}
192.167.255.251

# Get the next five addresses using CIDR notation
# {{ '192.168.1.1/24' | ansible.netcommon.ipmath(5) }}
192.168.1.6

# Get the previous five addresses using CIDR notation
# {{ '192.168.1.6/24' | ansible.netcommon.ipmath(-5) }}
192.168.1.1

# Get the previous ten address using cidr notation
# It returns a address of the previous network range
# {{ '192.168.2.6/24' | ansible.netcommon.ipmath(-10) }}
192.168.1.252

# Get the next ten addresses in IPv6
# {{ '2001::1' | ansible.netcommon.ipmath(10) }}
2001::b

# Get the previous ten address in IPv6
# {{ '2001::5' | ansible.netcommon.ipmath(-10) }}
2000:ffff:ffff:ffff:ffff:ffff:ffff:fffb

Работа с подсетями

Фильтр ipsubnet() можно использовать для работы с подсетями различными способами.

Вот пример IP-адреса и подсети:

address = '192.168.144.5'
subnet  = '192.168.0.0/16'

Чтобы проверить, является ли заданная строка подсетью, передайте ее через фильтр без аргументов. Если заданная строка является IP-адресом, она будет преобразована в подсеть:

# {{ address | ansible.netcommon.ipsubnet }}
192.168.144.5/32

# {{ subnet | ansible.netcommon.ipsubnet }}
192.168.0.0/16

Если вы укажете размер подсети в качестве первого параметра фильтра ipsubnet(), а размер подсети меньше текущего, вы получите количество подсетей, на которые можно разделить данную подсеть:

# {{ subnet | ansible.netcommon.ipsubnet(20) }}
16

Второй аргумент фильтра ipsubnet() — это индекс; указав его, вы можете получить новую подсеть с указанным размером:

# First subnet
# {{ subnet | ansible.netcommon.ipsubnet(20, 0) }}
192.168.0.0/20

# Last subnet
# {{ subnet | ansible.netcommon.ipsubnet(20, -1) }}
192.168.240.0/20

# Fifth subnet
# {{ subnet | ansible.netcommon.ipsubnet(20, 5) }}
192.168.80.0/20

# Fifth to last subnet
# {{ subnet | ansible.netcommon.ipsubnet(20, -5) }}
192.168.176.0/20

Если вы укажете IP-адрес вместо подсети и зададите размер подсети в качестве первого аргумента, фильтр ipsubnet() вместо этого вернет наибольшую подсеть, содержащую заданный IP-адрес:

# {{ address | ansible.netcommon.ipsubnet(20) }}
192.168.144.0/20

Указав номер индекса как второй аргумент, вы можете выбрать всё меньшие и меньшие подсети:

# First subnet
# {{ address | ansible.netcommon.ipsubnet(18, 0) }}
192.168.128.0/18

# Last subnet
# {{ address | ansible.netcommon.ipsubnet(18, -1) }}
192.168.144.4/31

# Fifth subnet
# {{ address | ansible.netcommon.ipsubnet(18, 5) }}
192.168.144.0/23

# Fifth to last subnet
# {{ address | ansible.netcommon.ipsubnet(18, -5) }}
192.168.144.0/27

Указав другую подсеть в качестве второго аргумента, если вторая подсеть включает первую, вы можете определить ранг первой подсети во второй

# The rank of the IP in the subnet (the IP is the 36870nth /32 of the subnet)
# {{ address | ansible.netcommon.ipsubnet(subnet) }}
36870

# The rank in the /24 that contain the address
# {{ address | ansible.netcommon.ipsubnet('192.168.144.0/24') }}
6

# An IP with the subnet in the first /30 in a /24
# {{ '192.168.144.1/30' | ansible.netcommon.ipsubnet('192.168.144.0/24') }}
1

# The fifth subnet /30 in a /24
# {{ '192.168.144.16/30' | ansible.netcommon.ipsubnet('192.168.144.0/24') }}
5

Если вторая подсеть не включает первую, фильтр ipsubnet() возвращает ошибку.

Вы можете использовать фильтр ipsubnet() с фильтром ipaddr() для, например, разделения заданного префикса /48 на более мелкие /64 подсети:

# {{ '193.0.2.0' | ansible.netcommon.ipaddr('6to4') | ipsubnet(64, 58820) | ansible.netcommon.ipaddr('1') }}
2002:c100:200:e5c4::1/64

Из-за размера подсетей IPv6, итерация по всем подсетям для поиска нужной может занять некоторое время на более медленных компьютерах, в зависимости от разницы в размерах подсетей.

Объединение подсетей

Фильтр cidr_merge() можно использовать для объединения подсетей или отдельных адресов в их минимальное представление, сворачивая перекрывающиеся подсети и объединяя смежные, где это возможно:

{{ ['192.168.0.0/17', '192.168.128.0/17', '192.168.128.1' ] | cidr_merge }}
# => ['192.168.0.0/16']

{{ ['192.168.0.0/24', '192.168.1.0/24', '192.168.3.0/24'] | cidr_merge }}
# => ['192.168.0.0/23', '192.168.3.0/24']

Изменение действия с «объединения» на «распространение» вернет наименьшую подсеть, содержащую все вводимые данные:

{{ ['192.168.0.0/24', '192.168.3.0/24'] | ansible.netcommon.cidr_merge('span') }}
# => '192.168.0.0/22'

{{ ['192.168.1.42', '192.168.42.1'] | ansible.netcommon.cidr_merge('span') }}
# => '192.168.0.0/18'

Фильтр MAC-адресов

Вы можете использовать фильтр hwaddr() для проверки, является ли заданная строка MAC-адресом, или конвертировать ее между различными форматами. Примеры:

# Example MAC address
macaddress = '1a:2b:3c:4d:5e:6f'

# Check if given string is a MAC address
# {{ macaddress | ansible.netcommon.hwaddr }}
1a:2b:3c:4d:5e:6f

# Convert MAC address to PostgreSQL format
# {{ macaddress | ansible.netcommon.hwaddr('pgsql') }}
1a2b3c:4d5e6f

# Convert MAC address to Cisco format
# {{ macaddress | ansible.netcommon.hwaddr('cisco') }}
1a2b.3c4d.5e6f

Поддерживаемые форматы приводят к следующим преобразованиям для MAC-адреса 1a:2b:3c:4d:5e:6f:

bare: 1A2B3C4D5E6F
bool: True
int: 28772997619311
cisco: 1a2b.3c4d.5e6f
eui48 or win: 1A-2B-3C-4D-5E-6F
linux or unix: 1a:2b:3c:4d:5e:6f:
pgsql, postgresql, or psql: 1a2b3c:4d5e6f

Генерация IPv6-адреса в режиме бессостоятельной конфигурации (SLAAC)

Фильтр slaac() генерирует IPv6-адрес для заданной сети и MAC-адреса в режиме бессостоятельной конфигурации:

# {{ 'fdcf:1894:23b5:d38c:0000:0000:0000:0000' | slaac('c2:31:b3:83:bf:2b') }}
fdcf:1894:23b5:d38c:c031:b3ff:fe83:bf2b