0
# Network Interfaces
1

2
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.
3

4
## Capabilities
5

6
### Network Interface Management
7

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

10
```python { .api }
11
class NetworkInterfacesOperations:
12
    def begin_create_or_update(self, resource_group_name: str, network_interface_name: str, parameters: NetworkInterface, **kwargs) -> LROPoller[NetworkInterface]:
13
        """
14
        Creates or updates a network interface.
15
        
16
        Args:
17
            resource_group_name (str): The name of the resource group
18
            network_interface_name (str): The name of the network interface
19
            parameters (NetworkInterface): Parameters supplied to create or update network interface
20
            
21
        Returns:
22
            LROPoller[NetworkInterface]: A poller object for the long-running operation
23
        """
24
    
25
    def get(self, resource_group_name: str, network_interface_name: str, *, expand: Optional[str] = None, **kwargs) -> NetworkInterface:
26
        """
27
        Gets information about the specified network interface.
28
        
29
        Args:
30
            resource_group_name (str): The name of the resource group
31
            network_interface_name (str): The name of the network interface
32
            expand (str, optional): Expands referenced resources
33
            
34
        Returns:
35
            NetworkInterface: The network interface resource
36
        """
37
    
38
    def begin_delete(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[None]:
39
        """
40
        Deletes the specified network interface.
41
        
42
        Args:
43
            resource_group_name (str): The name of the resource group
44
            network_interface_name (str): The name of the network interface
45
            
46
        Returns:
47
            LROPoller[None]: A poller object for the long-running operation
48
        """
49
    
50
    def list(self, resource_group_name: str, **kwargs) -> Iterable[NetworkInterface]:
51
        """
52
        Gets all network interfaces in a resource group.
53
        
54
        Args:
55
            resource_group_name (str): The name of the resource group
56
            
57
        Returns:
58
            Iterable[NetworkInterface]: Iterator of network interfaces
59
        """
60
    
61
    def list_all(self, **kwargs) -> Iterable[NetworkInterface]:
62
        """
63
        Gets all network interfaces in a subscription.
64
        
65
        Returns:
66
            Iterable[NetworkInterface]: Iterator of network interfaces
67
        """
68
    
69
    def update_tags(self, resource_group_name: str, network_interface_name: str, parameters: TagsObject, **kwargs) -> NetworkInterface:
70
        """
71
        Updates network interface tags.
72
        
73
        Args:
74
            resource_group_name (str): The name of the resource group
75
            network_interface_name (str): The name of the network interface
76
            parameters (TagsObject): Parameters supplied to update network interface tags
77
            
78
        Returns:
79
            NetworkInterface: The updated network interface
80
        """
81
    
82
    def get_effective_route_table(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[EffectiveRouteListResult]:
83
        """
84
        Gets all route tables applied to a network interface.
85
        
86
        Args:
87
            resource_group_name (str): The name of the resource group
88
            network_interface_name (str): The name of the network interface
89
            
90
        Returns:
91
            LROPoller[EffectiveRouteListResult]: A poller object for the long-running operation
92
        """
93
    
94
    def list_effective_network_security_groups(self, resource_group_name: str, network_interface_name: str, **kwargs) -> LROPoller[EffectiveNetworkSecurityGroupListResult]:
95
        """
96
        Gets all network security groups applied to a network interface.
97
        
98
        Args:
99
            resource_group_name (str): The name of the resource group
100
            network_interface_name (str): The name of the network interface
101
            
102
        Returns:
103
            LROPoller[EffectiveNetworkSecurityGroupListResult]: A poller object for the long-running operation
104
        """
105
```
106

107
### Network Interface IP Configurations
108

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

111
```python { .api }
112
class NetworkInterfaceIPConfigurationsOperations:
113
    def get(self, resource_group_name: str, network_interface_name: str, ip_configuration_name: str, **kwargs) -> NetworkInterfaceIPConfiguration:
114
        """
115
        Gets the specified network interface IP configuration.
116
        
117
        Args:
118
            resource_group_name (str): The name of the resource group
119
            network_interface_name (str): The name of the network interface
120
            ip_configuration_name (str): The name of the IP configuration
121
            
122
        Returns:
123
            NetworkInterfaceIPConfiguration: The IP configuration resource
124
        """
125
    
126
    def list(self, resource_group_name: str, network_interface_name: str, **kwargs) -> Iterable[NetworkInterfaceIPConfiguration]:
127
        """
128
        Get all IP configurations in a network interface.
129
        
130
        Args:
131
            resource_group_name (str): The name of the resource group
132
            network_interface_name (str): The name of the network interface
133
            
134
        Returns:
135
            Iterable[NetworkInterfaceIPConfiguration]: Iterator of IP configurations
136
        """
137
```
138

139
## Types
140

141
```python { .api }
142
class NetworkInterface(Resource):
143
    def __init__(self, **kwargs): ...
144
    virtual_machine: Optional[SubResource]  # Read-only
145
    network_security_group: Optional[NetworkSecurityGroup]
146
    private_endpoint: Optional[PrivateEndpoint]  # Read-only
147
    ip_configurations: Optional[List[NetworkInterfaceIPConfiguration]]
148
    tap_configurations: Optional[List[NetworkInterfaceTapConfiguration]]  # Read-only
149
    dns_settings: Optional[NetworkInterfaceDnsSettings]
150
    mac_address: Optional[str]  # Read-only
151
    primary: Optional[bool]  # Read-only
152
    vnet_encryption_supported: Optional[bool]  # Read-only
153
    enable_accelerated_networking: Optional[bool]
154
    disable_tcp_state_tracking: Optional[bool]
155
    enable_ip_forwarding: Optional[bool]
156
    hosted_workloads: Optional[List[str]]  # Read-only
157
    dscp_configuration: Optional[SubResource]  # Read-only
158
    resource_guid: Optional[str]  # Read-only
159
    provisioning_state: Optional[ProvisioningState]  # Read-only
160
    workload_type: Optional[str]
161
    nic_type: Optional[NetworkInterfaceNicType]
162
    private_link_service: Optional[PrivateLinkService]
163
    migration_phase: Optional[NetworkInterfaceMigrationPhase]
164
    auxiliary_mode: Optional[NetworkInterfaceAuxiliaryMode]
165
    auxiliary_sku: Optional[NetworkInterfaceAuxiliarySku]
166

167
class NetworkInterfaceIPConfiguration(SubResource):
168
    def __init__(self, **kwargs): ...
169
    virtual_network_taps: Optional[List[VirtualNetworkTap]]
170
    application_gateway_backend_address_pools: Optional[List[ApplicationGatewayBackendAddressPool]]
171
    load_balancer_backend_address_pools: Optional[List[BackendAddressPool]]
172
    load_balancer_inbound_nat_rules: Optional[List[InboundNatRule]]
173
    private_ip_address: Optional[str]
174
    private_ip_allocation_method: Optional[IPAllocationMethod]
175
    private_ip_address_version: Optional[IPVersion]
176
    subnet: Optional[Subnet]
177
    primary: Optional[bool]
178
    public_ip_address: Optional[PublicIPAddress]
179
    application_security_groups: Optional[List[ApplicationSecurityGroup]]
180
    provisioning_state: Optional[ProvisioningState]  # Read-only
181
    private_link_connection_properties: Optional[NetworkInterfaceIPConfigurationPrivateLinkConnectionProperties]  # Read-only
182
    gateway_load_balancer: Optional[SubResource]
183

184
class NetworkInterfaceDnsSettings:
185
    def __init__(self, **kwargs): ...
186
    dns_servers: Optional[List[str]]
187
    applied_dns_servers: Optional[List[str]]  # Read-only
188
    internal_dns_name_label: Optional[str]
189
    internal_fqdn: Optional[str]  # Read-only
190
    internal_domain_name_suffix: Optional[str]  # Read-only
191

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

197
class EffectiveRoute:
198
    def __init__(self, **kwargs): ...
199
    name: Optional[str]
200
    disable_bgp_route_propagation: Optional[bool]
201
    source: Optional[EffectiveRouteSource]
202
    state: Optional[EffectiveRouteState]
203
    address_prefix: Optional[List[str]]
204
    next_hop_ip_address: Optional[List[str]]
205
    next_hop_type: Optional[RouteNextHopType]
206

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

212
class EffectiveNetworkSecurityGroup:
213
    def __init__(self, **kwargs): ...
214
    network_security_group: Optional[SubResource]
215
    association: Optional[EffectiveNetworkSecurityGroupAssociation]
216
    effective_security_rules: Optional[List[EffectiveNetworkSecurityRule]]
217
    tag_map: Optional[str]
218

219
# Enumerations
220
class NetworkInterfaceNicType(str, Enum):
221
    STANDARD = "Standard"
222
    ELASTIC = "Elastic"
223

224
class NetworkInterfaceMigrationPhase(str, Enum):
225
    NONE = "None"
226
    PREPARE = "Prepare"
227
    COMMIT = "Commit"
228
    ABORT = "Abort"
229
    COMMITTED = "Committed"
230

231
class NetworkInterfaceAuxiliaryMode(str, Enum):
232
    NONE = "None"
233
    MACSEC = "MacSec"
234
    FLOATING = "Floating"
235
    ACCELERATED_CONNECTIONS = "AcceleratedConnections"
236

237
class NetworkInterfaceAuxiliarySku(str, Enum):
238
    NONE = "None"
239
    A1 = "A1"
240
    A2 = "A2"
241
    A4 = "A4"
242
    A8 = "A8"
243

244
class IPAllocationMethod(str, Enum):
245
    STATIC = "Static"
246
    DYNAMIC = "Dynamic"
247

248
class IPVersion(str, Enum):
249
    IPV4 = "IPv4"
250
    IPV6 = "IPv6"
251

252
class EffectiveRouteSource(str, Enum):
253
    UNKNOWN = "Unknown"
254
    USER = "User"
255
    VIRTUAL_NETWORK_GATEWAY = "VirtualNetworkGateway"
256
    DEFAULT = "Default"
257

258
class EffectiveRouteState(str, Enum):
259
    ACTIVE = "Active"
260
    INVALID = "Invalid"
261

262
class RouteNextHopType(str, Enum):
263
    VIRTUAL_NETWORK_GATEWAY = "VirtualNetworkGateway"
264
    VNET_LOCAL = "VnetLocal"
265
    INTERNET = "Internet"
266
    VIRTUAL_APPLIANCE = "VirtualAppliance"
267
    NONE = "None"
268
```