AI-Optimized Infrastructure with AWS EKS Spot Instances

Question

Pulumi · Accepted Answer

In order to build an AI-Optimized Infrastructure on AWS using Amazon Elastic Kubernetes Service (EKS) with Spot Instances, we'll follow these steps:

1. Set up an EKS cluster using Pulumi's higher-level `eks` module. This simplifies the creation of an EKS cluster.
2. Configure the EKS cluster to utilize EC2 Spot Instances, which will allow us to optimize costs. Spot Instances are spare compute capacity in the AWS cloud available at a steep discount compared to On-Demand prices. Keep in mind that Spot Instances can be interrupted by AWS with two minutes of notification when AWS needs the capacity back.
3. The EKS cluster will also need a node group, which is a set of worker nodes that run your containers. We'll configure the node group to use Spot Instances.

The following program outlines the necessary steps to create this infrastructure. Please ensure you've configured your Pulumi environment and AWS credentials before running this program.

```python
import pulumi
import pulumi_aws as aws
import pulumi_eks as eks

# Create a VPC for our cluster.
vpc = aws.ec2.Vpc("vpc", cidr_block="10.100.0.0/16")

# Create subnets for the VPC.
subnet = aws.ec2.Subnet("subnet",
    vpc_id=vpc.id,
    cidr_block="10.100.1.0/24",
    availability_zone="us-west-2a" # Choose the appropriate availability zone.
)

# Create an EKS cluster.
cluster = eks.Cluster("cluster",
    vpc_id=vpc.id,
    subnet_ids=[subnet.id]
)

# Create an IAM instance profile for our EC2 instances in the node group.
instance_profile = aws.iam.InstanceProfile("instanceProfile",
    role=cluster.instance_roles[0].name
)

# Specify the size and configuration of our EC2 instances.
node_group_args = eks.NodeGroupArgs(
    instance_type="t3.medium", # Choose an instance type suitable for your workload.
    desired_capacity=2,
    min_size=1,
    max_size=3,
    labels={"ondemand": "false"},
    taints={
        "special": {
            "value": "true",
            "effect": "NoSchedule",
        },
    },
    instance_profile=instance_profile,
    spot_price="0.05", # Specify the maximum price you are willing to pay per instance hour.
)

# Create a managed node group using Spot Instances.
node_group = eks.NodeGroup("nodeGroup",
    cluster=cluster.core,
    node_group_args=node_group_args
)

# Export the cluster's kubeconfig.
pulumi.export('kubeconfig', cluster.kubeconfig)
```

In this program, we start by creating a VPC and a subnet to deploy our EKS cluster. This is a prerequisite for setting up an EKS cluster. You might want to consider creating more than one subnet for higher availability across multiple zones.

Following that, we initialize an EKS cluster within the created VPC and subnets. We then create an IAM instance profile for the EC2 instances that will be created in our node group. This profile is derived from the roles automatically created by the Pulumi EKS module.

Next, we define the parameters for our node group. These parameters include the type of instance we want to use, the desired capacity, and the maximum price we're willing to pay for the Spot Instances. Here we have specified a spot price that represents the maximum hourly rate you're willing to pay for the instances. If the spot market price for the chosen instance type exceeds this value, AWS can terminate the instances. The `labels` and `taints` are Kubernetes configurations to manage node scheduling.

Finally, we create a node group using Spot Instances with the previously defined settings. The `desired_capacity`, `min_size`, and `max_size` params allow us to specify the scaling characteristics of our node group, and the `spot_price` sets a maximum price for Spot Instances.

The `pulumi.export` line at the end of the code outputs the kubeconfig necessary to connect to the Kubernetes cluster with tools like `kubectl`.

This Pulumi program provides an efficient way to launch an EKS cluster using Spot Instances, paving the way for an AI-optimized infrastructure at a potentially lower cost. It is important to handle Spot Instance interruptions gracefully in the workload because they can be terminated by AWS when the spare capacity is no longer available.