NetworkInterface class

Provides an Elastic network interface (ENI) resource.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const test = new aws.ec2.NetworkInterface("test", {
    attachments: [{
        instance: testAwsInstance.id,
        deviceIndex: 1,
    }],
    subnetId: publicA.id,
    privateIps: ["10.0.0.50"],
    securityGroups: [web.id],
});

import pulumi
import pulumi_aws as aws

test = aws.ec2.NetworkInterface("test",
    attachments=[{
        "instance": test_aws_instance["id"],
        "device_index": 1,
    }],
    subnet_id=public_a["id"],
    private_ips=["10.0.0.50"],
    security_groups=[web["id"]])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.Ec2.NetworkInterface("test", new()
    {
        Attachments = new[]
        {
            new Aws.Ec2.Inputs.NetworkInterfaceAttachmentArgs
            {
                Instance = testAwsInstance.Id,
                DeviceIndex = 1,
            },
        },
        SubnetId = publicA.Id,
        PrivateIps = new[]
        {
            "10.0.0.50",
        },
        SecurityGroups = new[]
        {
            web.Id,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewNetworkInterface(ctx, "test", &ec2.NetworkInterfaceArgs{
			Attachments: ec2.NetworkInterfaceAttachmentTypeArray{
				&ec2.NetworkInterfaceAttachmentTypeArgs{
					Instance:    pulumi.Any(testAwsInstance.Id),
					DeviceIndex: pulumi.Int(1),
				},
			},
			SubnetId: pulumi.Any(publicA.Id),
			PrivateIps: pulumi.StringArray{
				pulumi.String("10.0.0.50"),
			},
			SecurityGroups: pulumi.StringArray{
				web.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_networkinterface" "test" {
  attachments {
    instance     = testAwsInstance.id
    device_index = 1
  }
  subnet_id       = publicA.id
  private_ips     = ["10.0.0.50"]
  security_groups = [web.id]
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.NetworkInterface;
import com.pulumi.aws.ec2.NetworkInterfaceArgs;
import com.pulumi.aws.ec2.inputs.NetworkInterfaceAttachmentArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var test = new NetworkInterface("test", NetworkInterfaceArgs.builder()
            .attachments(NetworkInterfaceAttachmentArgs.builder()
                .instance(testAwsInstance.id())
                .deviceIndex(1)
                .build())
            .subnetId(publicA.id())
            .privateIps("10.0.0.50")
            .securityGroups(web.id())
            .build());

    }
}

resources:
  test:
    type: aws:ec2:NetworkInterface
    properties:
      attachments:
        - instance: ${testAwsInstance.id}
          deviceIndex: 1
      subnetId: ${publicA.id}
      privateIps:
        - 10.0.0.50
      securityGroups:
        - ${web.id}

Example of Managing Multiple IPs on a Network Interface

By default, private IPs are managed through the privateIps and privateIpsCount arguments which manage IPs as a set of IPs that are configured without regard to order. For a new network interface, the same primary IP address is consistently selected from a given set of addresses, regardless of the order provided. However, modifications of the set of addresses of an existing interface will not alter the current primary IP address unless it has been removed from the set.

In order to manage the private IPs as a sequentially ordered list, configure privateIpListEnabled to true and use privateIpList to manage the IPs. This will disable the privateIps and privateIpsCount settings, which must be removed from the config file but are still exported. Note that changing the first address of privateIpList, which is the primary, always requires a new interface.

If you are managing a specific set or list of IPs, instead of just using privateIpsCount, this is a potential workflow for also leveraging privateIpsCount to have AWS automatically assign additional IP addresses:

1. Comment out privateIps, privateIpList, privateIpListEnabled in your configuration
2. Set the desired privateIpsCount (count of the number of secondaries, the primary is not included)
3. Apply to assign the extra IPs
4. Remove privateIpsCount and restore your settings from the first step
5. Add the new IPs to your current settings
6. Apply again to update the stored state

This process can also be used to remove IP addresses in addition to the option of manually removing them. Adding IP addresses in a manually is more difficult because it requires knowledge of which addresses are available.

Import

Identity Schema

Required

• id (String) ID of the network interface.

Optional

• accountId (String) AWS Account where this resource is managed.
• region (String) Region where this resource is managed.

Using pulumi import, import Network Interfaces using the id. For example:

$ pulumi import aws:ec2/networkInterface:NetworkInterface test eni-e5aa89a3