Secure ML Model Serving with Private EC2 Network Interfaces

Question

Pulumi · Accepted Answer

To securely serve an ML model using EC2 instances in AWS, you will need to create an Amazon EC2 instance and set up a network interface to ensure private networking. The purpose is to avoid exposing your ML model over the internet directly, and instead serve it within a Virtual Private Cloud (VPC). To do this, we will use the following resources:

1. `aws.ec2.Vpc`: A virtual private cloud (VPC) to provide a logically isolated section of the AWS Cloud.
2. `aws.ec2.Subnet`: Subnets to divide the VPC into multiple segments.
3. `aws.ec2.SecurityGroup`: Security groups to act as a virtual firewall for your instance to control inbound and outbound traffic.
4. `aws.ec2.Instance`: The actual EC2 instance where the ML model will be served.
5. `aws.ec2.NetworkInterface`: A network interface in your VPC to create a private network for your instances.

By attaching the EC2 instance to a private subnet and associating it with a security group that restricts inbound traffic only from allowed sources, you can serve an ML model with increased security.

Below is a Pulumi program, written in Python, that will set up the appropriate resources for this purpose. Remember to have your AWS credentials configured for Pulumi before running the program.

```python
import pulumi
import pulumi_aws as aws

# Create a new VPC
vpc = aws.ec2.Vpc("ml-vpc",
    cidr_block="10.0.0.0/16",
    enable_dns_hostnames=True)

# Create two subnets, one for the public and one for the private network
public_subnet = aws.ec2.Subnet("ml-public-subnet",
    vpc_id=vpc.id,
    cidr_block="10.0.1.0/24",
    map_public_ip_on_launch=True)

private_subnet = aws.ec2.Subnet("ml-private-subnet",
    vpc_id=vpc.id,
    cidr_block="10.0.2.0/24")

# Create a security group for the EC2 instance
security_group = aws.ec2.SecurityGroup("ml-security-group",
    vpc_id=vpc.id,
    description="Allow inbound traffic",
    egress=[aws.ec2.SecurityGroupEgressArgs(
        protocol="-1",
        from_port=0,
        to_port=0,
        cidr_blocks=["0.0.0.0/0"],
    )],
    ingress=[aws.ec2.SecurityGroupIngressArgs(
        protocol="tcp",
        from_port=22, # For SSH access
        to_port=22,
        cidr_blocks=["YOUR.IP.ADDRESS.HERE/32"], # Replace with your IP address for secure SSH access
    ), aws.ec2.SecurityGroupIngressArgs(
        protocol="tcp",
        from_port=80, # Adjust if your ML model serves on a different port
        to_port=80,
        cidr_blocks=["YOUR.IP.ADDRESS.HERE/32"], # Replace with your IP address or subnet
    )])

# Create an EC2 instance to serve the ML model
ml_instance = aws.ec2.Instance("ml-instance",
    ami="ami-0c55b159cbfafe1f0",  # Replace with the AMI ID of your choice
    instance_type="t2.micro",
    subnet_id=private_subnet.id,
    vpc_security_group_ids=[security_group.id],
    tags={
        "Name": "MLModelServer",
    })

# Create a network interface within the private subnet
ml_network_interface = aws.ec2.NetworkInterface("ml-network-interface",
    subnet_id=private_subnet.id,
    security_groups=[security_group.id])

# Attach the network interface to the instance
attachment = aws.ec2.NetworkInterfaceAttachment("ml-nic-attachment",
    instance_id=ml_instance.id,
    network_interface_id=ml_network_interface.id,
    device_index=1)

# Export the IDs and addresses of the resources we created
pulumi.export("vpc_id", vpc.id)
pulumi.export("public_subnet_id", public_subnet.id)
pulumi.export("private_subnet_id", private_subnet.id)
pulumi.export("security_group_id", security_group.id)
pulumi.export("ml_instance_id", ml_instance.id)
pulumi.export("ml_network_interface_id", ml_network_interface.id)
```

In this program:
- We create a VPC with a CIDR block that defines the IP range for the VPC.
- We define a public subnet with a CIDR block and enable automatic public IP assignment for instances launched in it.
- We define a private subnet where our ML model instances will reside without public IP addresses.
- We create a security group with rules to control traffic to the instances.
- We launch an EC2 instance in the private subnet, with the selected AMI and instance type, and attach it to our security group.
- We create a network interface and attach it to our EC2 instance. The device index `1` signifies that this is a secondary network interface on the instance.

Before using this program, you need to replace `"YOUR.IP.ADDRESS.HERE/32"` with your actual IP address to restrict SSH access to your instance, and you may need to adjust port numbers based on the specifics of your ML model serving application.

After deploying this program with Pulumi, your ML model will be served from an EC2 instance within a secure private network, minimizing the exposure to outside networks and potential threats.