Firewall Rules for Secure AI Model Deployment

Question

Pulumi · Accepted Answer

To securely deploy an AI model, we'll need to enforce firewall rules that control the traffic to the resources hosting the model. Firewall rules specify which type of access is allowed or denied to a certain resource. The rules can filter traffic based on factors like IP addresses, port numbers, protocols, and more. It helps in securing the model's deployment environment by limiting access to trusted sources and preventing unauthorized access.

To demonstrate how you can use Pulumi to create and manage firewall rules, let's take the example of deploying firewall rules in AWS using the `aws-native` provider. We will create an AWS Network Firewall resource, and define stateful and stateless rule groups that manage the traffic to our AI model deployment.

- **AWS Network Firewall**: A managed service that makes it easy to deploy essential network protections for all of your Amazon VPCs.
- **Stateful Rule Group**: Inspects the traffic based on the context of the traffic flow and keeps track of the state of network connections, such as TCP streams.
- **Stateless Rule Group**: Examines each packet in isolation, without considering the packet's context within a traffic flow.

Here is a program that creates an AWS Network Firewall with rule groups:

```python
import pulumi
import pulumi_aws_native as aws_native

# Create an AWS VPC -- this hosts all your network resources.
vpc = aws_native.ec2.Vpc("aiVpc",
    cidr_block="10.0.0.0/16")

# Create an AWS Network Firewall policy.
firewall_policy = aws_native.networkfirewall.FirewallPolicy("aiFirewallPolicy",
    firewall_policy=aws_native.networkfirewall.FirewallPolicyFirewallPolicyArgs(
        stateless_default_actions=["aws:forward_to_sfe"],
        stateless_fragment_default_actions=["aws:forward_to_sfe"]
    )
)

# Create an AWS Network Firewall.
network_firewall = aws_native.networkfirewall.Firewall("aiNetworkFirewall",
    firewall_policy_arn=firewall_policy.arn,
    vpc_id=vpc.id,
    firewall_name="aiModelFirewall",
    subnet_mappings=[aws_native.networkfirewall.FirewallSubnetMappingArgs(
        subnet_id="subnet-0bb1c79de3EXAMPLE"  # Replace with your actual subnet ID.
    )]
)

# Create an AWS Network Firewall Rule Group for stateful rules.
stateful_rule_group = aws_native.networkfirewall.RuleGroup("aiStatefulRuleGroup",
    type="STATEFUL",
    capacity=100,
    rule_group=aws_native.networkfirewall.RuleGroupRuleGroupArgs(
        rules_source=aws_native.networkfirewall.RuleGroupRulesSourceArgs(
            rules_source_list=aws_native.networkfirewall.RuleGroupRulesSourceListArgs(
                generated_rules_type="ALLOWLIST",
                target_types=["HTTP", "HTTPS"],
                targets=["203.0.113.0/24"]  # Replace with the IP range that is allowed to access your AI model.
            )
        )
    )
)

# Create an AWS Network Firewall Rule Group for stateless rules.
stateless_rule_group = aws_native.networkfirewall.RuleGroup("aiStatelessRuleGroup",
    type="STATELESS",
    capacity=100,
    rule_group=aws_native.networkfirewall.RuleGroupRuleGroupArgs(
        rules_source=aws_native.networkfirewall.RuleGroupRulesSourceArgs(
            stateless_rules_and_custom_actions=aws_native.networkfirewall.RuleGroupRulesSourceStatelessRulesAndCustomActionsArgs(
                stateless_rules=[
                    aws_native.networkfirewall.RuleGroupRulesSourceStatelessRulesAndCustomActionsStatelessRuleArgs(
                        priority=10,
                        rule_definition=aws_native.networkfirewall.RuleGroupRulesSourceStatelessRulesAndCustomActionsStatelessRuleRuleDefinitionArgs(
                            actions=["aws:pass"],
                            match_attributes=aws_native.networkfirewall.RuleGroupRulesSourceStatelessRulesAndCustomActionsStatelessRuleRuleDefinitionMatchAttributesArgs(
                                destinations=[
                                    aws_native.networkfirewall.RuleGroupAddressArgs(
                                        address_definition="203.0.113.0/24"  # Replace with the IP range that can access your AI model.
                                    )
                                ],
                                sources=[
                                    aws_native.networkfirewall.RuleGroupAddressArgs(
                                        address_definition="203.0.113.0/24"  # Replace with the IP range that can send traffic.
                                    )
                                ]
                            )
                        )
                    )
                ]
            )
        )
    )
)

# Output the IDs of created resources
pulumi.export("firewall_policy_id", firewall_policy.id)
pulumi.export("network_firewall_id", network_firewall.id)
pulumi.export("vpc_id", vpc.id)
pulumi.export("stateful_rule_group_id", stateful_rule_group.id)
pulumi.export("stateless_rule_group_id", stateless_rule_group.id)
```

In this program:
- We start by creating an Amazon VPC (Virtual Private Cloud) which provides an isolated cloud network to host our resources.
- We then set up a network firewall policy, to which we'll add the rule groups.
- We define both the stateful and stateless rule groups separately, focusing on ALLOWLIST which restricts all traffic except for what is explicitly allowed.
- The stateful rule group and stateless rule group define rules based on IP addresses for demonstration purposes; you should substitute these with real IP ranges applicable to your case.
- We export identifiers of the created resources for future reference or to use in other Pulumi stacks.

The IP ranges in `targets`, `destinations`, and `sources` should be the one(s) you expect to communicate with your AI model. They should be modified to match your requirements.

Note that this setup assumes a level of familiarity with AWS networking concepts. If you plan to implement these rules, you should replace placeholder values (like `subnet-0bb1c79de3EXAMPLE`) with actual values from your AWS environment.