Nuevo en la versión 1.9.
ipaddr() es un filtro Jinja2 diseñado para proporcionar una interfaz al netaddr Paquete de Python desde Ansible. Puede operar en cadenas o listas de elementos, probar varios datos para verificar si son direcciones IP válidas y manipular los datos de entrada para extraer la información solicitada. ipaddr() funciona con direcciones IPv4 e IPv6 en varias formas. También hay funciones adicionales disponibles para manipular subredes IP y direcciones MAC.
Nota
los ipaddr() filtro migrado al ansible.netcommon colección. Siga las instrucciones de instalación para instalar esa colección.
Para utilizar este filtro en Ansible, debe instalar el netaddr Biblioteca de Python en una computadora en la que usa Ansible (no es necesaria en hosts remotos). Por lo general, se puede instalar con el administrador de paquetes del sistema o usando pip:
pip install netaddr
- Pruebas basicas
- Filtrar listas
- Envolviendo direcciones IPv6 en [ ] soportes
- Consultas básicas
- Obtener información sobre hosts y redes
- Obtener información de los valores de host / prefijo
- Conversión de máscaras de subred a notación CIDR
- Obtener información sobre la red en notación CIDR
- Conversión de dirección IP
- Conversión de la dirección IPv4 en una dirección 6to4
- Encontrar direcciones IP dentro de un rango
- Prueba de si una dirección pertenece a un rango de red
- Matemáticas IP
- Manipulación de subredes
- Fusión de subredes
- Filtro de dirección MAC
- Genere una dirección IPv6 en configuración sin estado (SLAAC)
Pruebas basicas
ipaddr() está diseñado para devolver el valor de entrada si una consulta es verdadera, y False si una consulta es falsa. De esta forma se puede utilizar fácilmente en filtros encadenados. Para usar el filtro, pásale una cadena:
{{ '192.0.2.0' | ansible.netcommon.ipaddr }}
También puede pasar los valores como variables:
{{ myvar | ansible.netcommon.ipaddr }}
A continuación, se muestran algunos resultados de prueba de ejemplo de varias cadenas de entrada:
# 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
A veces, necesita direcciones IPv4 o IPv6. Para filtrar solo por un tipo en particular, ipaddr() el filtro tiene dos “alias”, ipv4() y ipv6().
Ejemplo de uso de un filtro IPv4:
{{ myvar | ansible.netcommon.ipv4 }}
Un ejemplo similar de un filtro IPv6:
{{ myvar | ansible.netcommon.ipv6 }}
A continuación, se muestran algunos resultados de prueba de ejemplo para buscar direcciones 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
Y los mismos datos filtrados para direcciones 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
Filtrar listas
Puede filtrar listas completas: ipaddr() devolverá una lista con valores válidos para una consulta en particular:
# 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']
Envolviendo direcciones IPv6 en [ ] soportes
Algunos archivos de configuración requieren que las direcciones IPv6 estén “envueltas” entre corchetes ([ ]). Para lograr eso, puede usar el ipwrap() filtrar. Envolverá todas las direcciones IPv6 y dejará intactas las demás cadenas:
# {{ 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']
Como se puede ver, ipwrap() no filtró los valores de direcciones que no son IP, que suele ser lo que desea cuando, por ejemplo, está mezclando direcciones IP con nombres de host. Si aún desea filtrar todos los valores de direcciones que no sean IP, puede encadenar ambos filtros:
# {{ 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']
Consultas básicas
Puede proporcionar un único argumento a cada ipaddr() filtrar. El filtro lo tratará como una consulta y devolverá valores modificados por esa consulta. Las listas contendrán solo los valores que está consultando.
Los tipos de consultas incluyen:
- consulta por nombre:
ansible.netcommon.ipaddr('address'),ansible.netcommon.ipv4('network'); - consulta por rango CIDR:
ansible.netcommon.ipaddr('192.168.0.0/24'),ansible.netcommon.ipv6('2001:db8::/32'); - consulta por número de índice:
ansible.netcommon.ipaddr('1'),ansible.netcommon.ipaddr('-1');
Si no se reconoce un tipo de consulta, Ansible generará un error.
Obtener información sobre hosts y redes
Aquí está nuestra lista de prueba nuevamente:
# Example list of values test_list = ['192.24.2.1', 'host.fqdn', '::1', '192.168.32.0/24', 'fe80::100/10', True, '', '42540766412265424405338506004571095040/64']
Tomemos la lista anterior y obtengamos solo aquellos elementos que son direcciones IP de host y no rangos de red:
# {{ test_list | ansible.netcommon.ipaddr('address') }}
['192.24.2.1', '::1', 'fe80::100']
Como puede ver, aunque algunos valores tenían una dirección de host con un prefijo CIDR, el filtro los eliminó. Si desea direcciones IP de host con sus prefijos CIDR correctos (como es común con el direccionamiento IPv6), puede usar el ipaddr('host') filtrar:
# {{ test_list | ansible.netcommon.ipaddr('host') }}
['192.24.2.1/32', '::1/128', 'fe80::100/10']
El filtrado por tipo de dirección IP también funciona:
# {{ test_list | ansible.netcommon.ipv4('address') }}
['192.24.2.1']
# {{ test_list | ansible.netcommon.ipv6('address') }}
['::1', 'fe80::100']
Puede verificar si las direcciones IP o los rangos de red son accesibles en una Internet pública, o si están en redes privadas:
# {{ 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']
Puede verificar qué valores son específicamente rangos de red:
# {{ test_list | ansible.netcommon.ipaddr('net') }}
['192.168.32.0/24', '2001:db8:32c:faad::/64']
También puede verificar cuántas direcciones IP pueden estar en un rango determinado:
# {{ test_list | ansible.netcommon.ipaddr('net') | ansible.netcommon.ipaddr('size') }}
[256, 18446744073709551616L]
Al especificar un rango de red como una consulta, puede verificar si un valor dado está en ese rango:
# {{ test_list | ansible.netcommon.ipaddr('192.0.0.0/8') }}
['192.24.2.1', '192.168.32.0/24']
Si especifica un entero positivo o negativo como consulta, ipaddr() tratará esto como un índice y devolverá la dirección IP específica de un rango de red, en el formato ‘host / prefijo’:
# 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']
También puede seleccionar direcciones IP de un rango por su índice, desde el inicio o el final del rango:
# 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']
Obtener información de los valores de host / prefijo
Con frecuencia utiliza una combinación de direcciones IP y prefijos de subred (“CIDR”), esto es aún más común con IPv6. los ansible.netcommon.ipaddr() filter puede extraer datos útiles de estos prefijos.
A continuación, se muestra un conjunto de ejemplo de dos prefijos de host (con algunos valores de “control”):
host_prefix = ['2001:db8:deaf:be11::ef3/64', '192.0.2.48/24', '127.0.0.1', '192.168.0.0/16']
Primero, asegurémonos de trabajar solo con valores correctos de host / prefijo, no solo subredes o direcciones IP únicas:
# {{ host_prefix | ansible.netcommon.ipaddr('host/prefix') }}
['2001:db8:deaf:be11::ef3/64', '192.0.2.48/24']
En los sistemas basados en Debian, la configuración de red almacenada en el /etc/network/interfaces El archivo utiliza una combinación de dirección IP, dirección de red, máscara de red y dirección de transmisión para configurar una interfaz de red IPv4. Podemos obtener estos valores de una sola combinación de ‘host / prefijo’:
# 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
En el ejemplo anterior, necesitábamos manejar el hecho de que los valores se almacenaron en una lista, lo cual es inusual en las redes IPv4, donde solo se puede configurar una única dirección IP en una interfaz. Sin embargo, las redes IPv6 pueden tener varias direcciones IP configuradas en una interfaz:
# 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
Si es necesario, puede extraer información de subred y prefijo del valor ‘host / prefijo’:
# {{ 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]
Conversión de máscaras de subred a notación CIDR
Dada una subred en forma de dirección de red y máscara de subred, el ipaddr() filter puede convertirlo en notación CIDR. Esto puede ser útil para convertir los datos de Ansible recopilados sobre la configuración de red de las máscaras de subred al formato 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"
}
Primero concatenar la red y la máscara de red:
net_mask = "{{ ansible_default_ipv4.network }}/{{ ansible_default_ipv4.netmask }}"
'192.168.0.0/255.255.255.0'
Este resultado se puede convertir a forma canónica con ipaddr() para producir una subred en formato CIDR:
# {{ net_mask | ansible.netcommon.ipaddr('prefix') }}
'24'
# {{ net_mask | ansible.netcommon.ipaddr('net') }}
'192.168.0.0/24'
Obtener información sobre la red en notación CIDR
Dada una dirección IP, el ipaddr() El filtro puede producir la dirección de red en notación CIDR. Esto puede resultar útil cuando desee obtener la dirección de red de la dirección IP en formato CIDR.
A continuación, se muestra un ejemplo de dirección IP:
ip_address = "{{ ansible_default_ipv4.address }}/{{ ansible_default_ipv4.netmask }}"
'192.168.0.11/255.255.255.0'
Esto se puede utilizar para obtener la dirección de red en formato de notación CIDR:
# {{ ip_address | ansible.netcommon.ipaddr('network/prefix') }}
'192.168.0.0/24'
Conversión de dirección IP
Aquí está nuestra lista de prueba nuevamente:
# Example list of values test_list = ['192.24.2.1', 'host.fqdn', '::1', '192.168.32.0/24', 'fe80::100/10', True, '', '42540766412265424405338506004571095040/64']
Puede convertir direcciones IPv4 en direcciones IPv6:
# {{ test_list | ansible.netcommon.ipv4('ipv6') }}
['::ffff:192.24.2.1/128', '::ffff:192.168.32.0/120']
La conversión de IPv6 a IPv4 funciona muy raramente:
# {{ test_list | ansible.netcommon.ipv6('ipv4') }}
['0.0.0.1/32']
Pero podemos hacer una doble conversión si es necesario:
# {{ 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']
Puede convertir direcciones IP en números enteros, de la misma forma que puede convertir números enteros en direcciones IP:
# {{ test_list | ansible.netcommon.ipaddr('address') | ansible.netcommon.ipaddr('int') }}
[3222798849, 1, '3232243712/24', '338288524927261089654018896841347694848/10', '42540766412265424405338506004571095040/64']
Puede convertir la dirección IPv4 a Notación hexadecimal con delimitador opcional:
# {{ '192.168.1.5' | ansible.netcommon.ip4_hex }}
c0a80105
# {{ '192.168.1.5' | ansible.netcommon.ip4_hex(':') }}
c0:a8:01:05
Puede convertir direcciones IP en registros 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.
Conversión de la dirección IPv4 en una dirección 6to4
A 6to4 El túnel es una forma de acceder a Internet IPv6 desde una red solo IPv4. Si tiene una dirección IPv4 pública, puede configurar automáticamente su equivalente IPv6 en la 2002::/16 rango de red. Después de la conversión, obtendrá acceso a un 2002:xxxx:xxxx::/48 subred que podría dividirse en 65535 /64 subredes si es necesario.
Para convertir su dirección IPv4, simplemente envíela a través del '6to4' filtrar. Se convertirá automáticamente en una dirección de enrutador (con un ::1/48 Dirección del servidor):
# {{ '193.0.2.0' | ansible.netcommon.ipaddr('6to4') }}
2002:c100:0200::1/48
Encontrar direcciones IP dentro de un rango
Para encontrar direcciones IP utilizables dentro de un rango de IP, pruebe estos ipaddr filtros:
Para encontrar la siguiente dirección IP utilizable en un rango, use next_usable
# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('next_usable') }}
192.168.122.2
Para encontrar la última dirección IP utilizable de un rango, use last_usable:
# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('last_usable') }}
192.168.122.254
Para encontrar el rango disponible de direcciones IP de la dirección de red dada, use range_usable:
# {{ '192.168.122.1/24' | ansible.netcommon.ipaddr('range_usable') }}
192.168.122.1-192.168.122.254
Para encontrar la dirección IP del par para un enlace punto a punto, use 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
Para devolver la enésima ip de una red, use el filtro nthhost:
# {{ '10.0.0.0/8' | ansible.netcommon.nthhost(305) }}
10.0.1.49
nthhost también admite un valor negativo:
# {{ '10.0.0.0/8' | ansible.netcommon.nthhost(-1) }}
10.255.255.255
Para encontrar la siguiente enésima dirección IP utilizable en relación con otra dentro de un rango, utilice next_nth_usable En el ejemplo, next_nth_usable devuelve la segunda dirección IP utilizable para el rango de IP dado:
# {{ '192.168.122.1/24' | ansible.netcommon.next_nth_usable(2) }}
192.168.122.3
Si no hay una dirección utilizable, devuelve una cadena vacía:
# {{ '192.168.122.254/24' | ansible.netcommon.next_nth_usable(2) }}
""
Al igual que next_nth_ansible, tú tienes previous_nth_usable para encontrar la dirección utilizable anterior:
# {{ '192.168.122.10/24' | ansible.netcommon.previous_nth_usable(2) }}
192.168.122.8
Prueba de si una dirección pertenece a un rango de red
los network_in_usable filter devuelve si una dirección pasada como argumento se puede utilizar en una red. Las direcciones utilizables son direcciones que se pueden asignar a un host. El ID de red y la dirección de transmisión no son direcciones utilizables:
# {{ '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
los network_in_network filter devuelve si una dirección o una red pasada como argumento está en una red:
# {{ '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
Para comprobar si varias direcciones pertenecen a una red, utilice el reduce_on_network filtrar:
# {{ ['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']
Matemáticas IP
Nuevo en la versión 2.7.
los ipmath() El filtro se puede utilizar para realizar operaciones matemáticas / aritméticas simples de IP.
A continuación, se muestran algunos ejemplos sencillos:
# 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
Manipulación de subred
los ipsubnet() El filtro se puede utilizar para manipular subredes de red de varias formas.
A continuación, se muestra una dirección IP y una subred de ejemplo:
address="192.168.144.5" subnet="192.168.0.0/16"
Para comprobar si una cadena determinada es una subred, pásala por el filtro sin ningún argumento. Si la cadena dada es una dirección IP, se convertirá en una subred:
# {{ address | ansible.netcommon.ipsubnet }}
192.168.144.5/32
# {{ subnet | ansible.netcommon.ipsubnet }}
192.168.0.0/16
Si especifica un tamaño de subred como primer parámetro del ipsubnet() filtro, y el tamaño de la subred es más pequeño que el actual, obtendrá la cantidad de subredes en las que se puede dividir una subred determinada:
# {{ subnet | ansible.netcommon.ipsubnet(20) }}
16
El segundo argumento de la ipsubnet() filtro es un número de índice; al especificarlo, puede obtener una nueva subred con el tamaño especificado:
# 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
Si especifica una dirección IP en lugar de una subred y da un tamaño de subred como primer argumento, el ipsubnet() en su lugar, el filtro devolverá la subred más grande que contiene esa dirección IP dada:
# {{ address | ansible.netcommon.ipsubnet(20) }}
192.168.144.0/20
Al especificar un número de índice como segundo argumento, puede seleccionar subredes cada vez más pequeñas:
# 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
Al especificar otra subred como segundo argumento, si la segunda subred incluye la primera, puede determinar el rango de la primera subred en la segunda.
# 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
Si la segunda subred no incluye la primera subred, el ipsubnet() filtro genera un error.
Puedes usar el ipsubnet() filtrar con el ipaddr() filtrar para, por ejemplo, dividir un determinado /48 prefijo en más pequeño /64 subredes:
# {{ '193.0.2.0' | ansible.netcommon.ipaddr('6to4') | ipsubnet(64, 58820) | ansible.netcommon.ipaddr('1') }}
2002:c100:200:e5c4::1/64
Debido al tamaño de las subredes IPv6, la iteración sobre todas ellas para encontrar la correcta puede llevar algún tiempo en computadoras más lentas, dependiendo de la diferencia de tamaño entre las subredes.
Fusión de subredes
Nuevo en la versión 2.6.
los cidr_merge() El filtro se puede utilizar para fusionar subredes o direcciones individuales en su representación mínima, colapsando subredes superpuestas y fusionando las adyacentes en cualquier lugar. posible:
{{ ['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']
Cambiar la acción de ‘fusionar’ a ‘span’ devolverá la subred más pequeña que contiene todas las entradas:
{{ ['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'
Filtro de dirección MAC
Puedes usar el hwaddr() filtrar para verificar si una cadena dada es una dirección MAC o convertirla entre varios formatos. Ejemplos:
# 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
Los formatos admitidos dan como resultado las siguientes conversiones para el 1a:2b:3c:4d:5e:6f Dirección MAC:
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
Genere una dirección IPv6 en configuración sin estado (SLAAC)
el filtro slaac() genera una dirección IPv6 para una red determinada y una dirección MAC en configuración sin estado:
# {{ 'fdcf:1894:23b5:d38c:0000:0000:0000:0000' | slaac('c2:31:b3:83:bf:2b') }}
fdcf:1894:23b5:d38c:c031:b3ff:fe83:bf2b
Ver también
- ansible.netcommon
-
Colección de red Ansible para código común
- Introducción a los libros de jugadas
-
Introducción a los libros de jugadas
- Usar filtros para manipular datos
-
Introducción a los filtros Jinja2 y sus usos
- Condicionales
-
Declaraciones condicionales en libros de jugadas
- Usando Variables
-
Todo sobre variables
- Bucles
-
Bucle en los libros de jugadas
- Roles
-
Organización del libro de jugadas por roles
- Consejos y trucos
-
Consejos y trucos para libros de jugadas
- Lista de correo de usuarios
-
¿Tengo una pregunta? ¡Pasa por el grupo de google!
- irc.freenode.net
-
Canal de chat de IRC #ansible