CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-azure-mgmt-network

Microsoft Azure Network Management Client Library for Python

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview
Eval results
Files

network-interfaces.mddocs/

Network Interfaces

Azure Network Interfaces (NICs) provide network connectivity for virtual machines and other compute resources. This module provides comprehensive management of network interfaces, IP configurations, and network interface associations.

Capabilities

Network Interface Management

Create, configure, and manage Azure Network Interfaces including IP configurations, DNS settings, security groups, and load balancer associations.

class NetworkInterfacesOperations:
    def begin_create_or_update(self, resource_group_name: str, network_interface_name: str, parameters: NetworkInterface, **kwargs) -> LROPoller[NetworkInterface]:
        """
        Creates or updates a network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            parameters (NetworkInterface): Parameters supplied to create or update network interface
            
        Returns:
            LROPoller[NetworkInterface]: A poller object for the long-running operation
        """
    
    def get(self, resource_group_name: str, network_interface_name: str, *, expand: Optional[str] = None, **kwargs) -> NetworkInterface:
        """
        Gets information about the specified network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            expand (str, optional): Expands referenced resources
            
        Returns:
            NetworkInterface: The network interface resource
        """
    
    def begin_delete(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[None]:
        """
        Deletes the specified network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            
        Returns:
            LROPoller[None]: A poller object for the long-running operation
        """
    
    def list(self, resource_group_name: str, **kwargs) -> Iterable[NetworkInterface]:
        """
        Gets all network interfaces in a resource group.
        
        Args:
            resource_group_name (str): The name of the resource group
            
        Returns:
            Iterable[NetworkInterface]: Iterator of network interfaces
        """
    
    def list_all(self, **kwargs) -> Iterable[NetworkInterface]:
        """
        Gets all network interfaces in a subscription.
        
        Returns:
            Iterable[NetworkInterface]: Iterator of network interfaces
        """
    
    def update_tags(self, resource_group_name: str, network_interface_name: str, parameters: TagsObject, **kwargs) -> NetworkInterface:
        """
        Updates network interface tags.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            parameters (TagsObject): Parameters supplied to update network interface tags
            
        Returns:
            NetworkInterface: The updated network interface
        """
    
    def get_effective_route_table(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[EffectiveRouteListResult]:
        """
        Gets all route tables applied to a network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            
        Returns:
            LROPoller[EffectiveRouteListResult]: A poller object for the long-running operation
        """
    
    def list_effective_network_security_groups(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[EffectiveNetworkSecurityGroupListResult]:
        """
        Gets all network security groups applied to a network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            
        Returns:
            LROPoller[EffectiveNetworkSecurityGroupListResult]: A poller object for the long-running operation
        """

Network Interface IP Configurations

Manage IP configurations for network interfaces including private and public IP addresses, subnets, and load balancer backend pools.

class NetworkInterfaceIPConfigurationsOperations:
    def get(self, resource_group_name: str, network_interface_name: str, ip_configuration_name: str, **kwargs) -> NetworkInterfaceIPConfiguration:
        """
        Gets the specified network interface IP configuration.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            ip_configuration_name (str): The name of the IP configuration
            
        Returns:
            NetworkInterfaceIPConfiguration: The IP configuration resource
        """
    
    def list(self, resource_group_name: str, network_interface_name: str, **kwargs) -> Iterable[NetworkInterfaceIPConfiguration]:
        """
        Get all IP configurations in a network interface.
        
        Args:
            resource_group_name (str): The name of the resource group
            network_interface_name (str): The name of the network interface
            
        Returns:
            Iterable[NetworkInterfaceIPConfiguration]: Iterator of IP configurations
        """

Types

class NetworkInterface(Resource):
    def __init__(self, **kwargs): ...
    virtual_machine: Optional[SubResource]  # Read-only
    network_security_group: Optional[NetworkSecurityGroup]
    private_endpoint: Optional[PrivateEndpoint]  # Read-only
    ip_configurations: Optional[List[NetworkInterfaceIPConfiguration]]
    tap_configurations: Optional[List[NetworkInterfaceTapConfiguration]]  # Read-only
    dns_settings: Optional[NetworkInterfaceDnsSettings]
    mac_address: Optional[str]  # Read-only
    primary: Optional[bool]  # Read-only
    vnet_encryption_supported: Optional[bool]  # Read-only
    enable_accelerated_networking: Optional[bool]
    disable_tcp_state_tracking: Optional[bool]
    enable_ip_forwarding: Optional[bool]
    hosted_workloads: Optional[List[str]]  # Read-only
    dscp_configuration: Optional[SubResource]  # Read-only
    resource_guid: Optional[str]  # Read-only
    provisioning_state: Optional[ProvisioningState]  # Read-only
    workload_type: Optional[str]
    nic_type: Optional[NetworkInterfaceNicType]
    private_link_service: Optional[PrivateLinkService]
    migration_phase: Optional[NetworkInterfaceMigrationPhase]
    auxiliary_mode: Optional[NetworkInterfaceAuxiliaryMode]
    auxiliary_sku: Optional[NetworkInterfaceAuxiliarySku]

class NetworkInterfaceIPConfiguration(SubResource):
    def __init__(self, **kwargs): ...
    virtual_network_taps: Optional[List[VirtualNetworkTap]]
    application_gateway_backend_address_pools: Optional[List[ApplicationGatewayBackendAddressPool]]
    load_balancer_backend_address_pools: Optional[List[BackendAddressPool]]
    load_balancer_inbound_nat_rules: Optional[List[InboundNatRule]]
    private_ip_address: Optional[str]
    private_ip_allocation_method: Optional[IPAllocationMethod]
    private_ip_address_version: Optional[IPVersion]
    subnet: Optional[Subnet]
    primary: Optional[bool]
    public_ip_address: Optional[PublicIPAddress]
    application_security_groups: Optional[List[ApplicationSecurityGroup]]
    provisioning_state: Optional[ProvisioningState]  # Read-only
    private_link_connection_properties: Optional[NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties]  # Read-only
    gateway_load_balancer: Optional[SubResource]

class NetworkInterfaceDnsSettings:
    def __init__(self, **kwargs): ...
    dns_servers: Optional[List[str]]
    applied_dns_servers: Optional[List[str]]  # Read-only
    internal_dns_name_label: Optional[str]
    internal_fqdn: Optional[str]  # Read-only
    internal_domain_name_suffix: Optional[str]  # Read-only

class EffectiveRouteListResult:
    def __init__(self, **kwargs): ...
    value: Optional[List[EffectiveRoute]]
    next_link: Optional[str]  # Read-only

class EffectiveRoute:
    def __init__(self, **kwargs): ...
    name: Optional[str]
    disable_bgp_route_propagation: Optional[bool]
    source: Optional[EffectiveRouteSource]
    state: Optional[EffectiveRouteState]
    address_prefix: Optional[List[str]]
    next_hop_ip_address: Optional[List[str]]
    next_hop_type: Optional[RouteNextHopType]

class EffectiveNetworkSecurityGroupListResult:
    def __init__(self, **kwargs): ...
    value: Optional[List[EffectiveNetworkSecurityGroup]]
    next_link: Optional[str]  # Read-only

class EffectiveNetworkSecurityGroup:
    def __init__(self, **kwargs): ...
    network_security_group: Optional[SubResource]
    association: Optional[EffectiveNetworkSecurityGroupAssociation]
    effective_security_rules: Optional[List[EffectiveNetworkSecurityRule]]
    tag_map: Optional[str]

# Enumerations
class NetworkInterfaceNicType(str, Enum):
    STANDARD = "Standard"
    ELASTIC = "Elastic"

class NetworkInterfaceMigrationPhase(str, Enum):
    NONE = "None"
    PREPARE = "Prepare"
    COMMIT = "Commit"
    ABORT = "Abort"
    COMMITTED = "Committed"

class NetworkInterfaceAuxiliaryMode(str, Enum):
    NONE = "None"
    MACSEC = "MacSec"
    FLOATING = "Floating"
    ACCELERATED_CONNECTIONS = "AcceleratedConnections"

class NetworkInterfaceAuxiliarySku(str, Enum):
    NONE = "None"
    A1 = "A1"
    A2 = "A2"
    A4 = "A4"
    A8 = "A8"

class IPAllocationMethod(str, Enum):
    STATIC = "Static"
    DYNAMIC = "Dynamic"

class IPVersion(str, Enum):
    IPV4 = "IPv4"
    IPV6 = "IPv6"

class EffectiveRouteSource(str, Enum):
    UNKNOWN = "Unknown"
    USER = "User"
    VIRTUAL_NETWORK_GATEWAY = "VirtualNetworkGateway"
    DEFAULT = "Default"

class EffectiveRouteState(str, Enum):
    ACTIVE = "Active"
    INVALID = "Invalid"

class RouteNextHopType(str, Enum):
    VIRTUAL_NETWORK_GATEWAY = "VirtualNetworkGateway"
    VNET_LOCAL = "VnetLocal"
    INTERNET = "Internet"
    VIRTUAL_APPLIANCE = "VirtualAppliance"
    NONE = "None"

Install with Tessl CLI

npx tessl i tessl/pypi-azure-mgmt-network

docs

index.md

load-balancers.md

network-interfaces.md

network-security.md

virtual-networks.md

tile.json