High-performance Computing for AI on EC2

Question

Pulumi · Accepted Answer

To accomplish high-performance computing (HPC) for AI on EC2, we'll need to configure a few AWS resources:

1. **EC2 Instances:** We'll select EC2 instance types that are optimized for compute-intensive tasks, such as the C5, P3, or G4 instances, which are suitable for HPC workloads.

2. **Placement Groups:** To ensure that the EC2 instances are physically close to each other, reducing the latency for the intense communication often required for HPC tasks, we'll use a placement group with a 'cluster' strategy.

3. **EBS Volumes (optional):** Depending on the workload, we may need to attach high-performance Elastic Block Store (EBS) volumes for storage.

4. **Security Groups:** We'll configure a security group to set up the networking access rules, allowing for secure communication between the EC2 instances.

5. **IAM Role (optional):** If your application needs to communicate with other AWS services, such as S3 or DynamoDB, you might need an IAM role with the necessary permissions attached to your instances.

Here's a Pulumi program that sets up a high-performance computing environment for AI on AWS EC2:

```python
import pulumi
import pulumi_aws as aws

# Configure the AWS provider
# Assuming AWS credentials and the default region are already set up in your environment.

# Define an EC2 instance optimized for HPC
# C5 instances are compute-optimized and suitable for HPC workloads
compute_instance_type = "c5.9xlarge"
ami_id = "ami-12345678"  # Replace with the actual AMI ID for your desired Linux distribution

# Create a new security group for the HPC cluster
security_group = aws.ec2.SecurityGroup("hpc-sg",
    description="Allow HPC traffic",
    ingress=[
        {"protocol": "tcp", "from_port": 0, "to_port": 65535, "cidr_blocks": ["0.0.0.0/0"]},
    ],
    egress=[
        {"protocol": "-1", "from_port": 0, "to_port": 0, "cidr_blocks": ["0.0.0.0/0"]},
    ]
)

# Create a new EC2 placement group for the HPC cluster
# This placement group ensures that instances are close together, reducing latency
placement_group = aws.ec2.PlacementGroup("hpc-cluster-pg",
    strategy="cluster"
)

# Create EC2 instances and associate them with the placement group and security group
instances = []
for i in range(4):  # You can adjust the number of instances based on your workload
    instance = aws.ec2.Instance(f"hpc-instance-{i}",
        instance_type=compute_instance_type,
        ami=ami_id,
        key_name="my-key-name",  # Replace with your key name for SSH access
        placement_group=placement_group.id,
        vpc_security_group_ids=[security_group.id],
        user_data="""
        #!/bin/bash
        echo "My custom startup script"  # Replace with your startup script
        """
    )
    instances.append(instance)

# Example of IAM role and instance profile (if needed)
# It's common to give EC2 instances a role for permissions to other services
role = aws.iam.Role("hpc-iam-role",
    assume_role_policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Action": "sts:AssumeRole",
            "Effect": "Allow",
            "Principal": {
                "Service": "ec2.amazonaws.com",
            },
        }]
    })
)

# Attach a policy to the role (if needed)
# This policy is quite open; in reality, you should scope this more narrowly to the resources your instances need to access
policy = aws.iam.RolePolicy("hpc-policy",
    role=role,
    policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Action": ["s3:*", "dynamodb:*", "ecr:*"],
            "Resource": "*",
            "Effect": "Allow",
        }]
    })
)

instance_profile = aws.iam.InstanceProfile("hpc-instance-profile", role=role)

# Now we assign the instance profile to our instances
for inst in instances:
    aws.ec2.InstanceProfileAttachment(f"hpc-profile-attach-{inst._name}",
        instance_id=inst.id,
        instance_profile=instance_profile
    )

pulumi.export("security_group", security_group.id)
pulumi.export("placement_group", placement_group.id)
```

In this program, we are setting up the necessary resources for an HPC environment suitable for AI-related computational work. We set up a security group to manage access to the instances, a placement group to minimize network latency between the instances, and a set of EC2 instances to perform the computations. The use of an IAM role and instance profile is optional but included, allowing you to grant your EC2 instances necessary permissions for AWS resources they might need to interact with.

Remember to replace `ami-12345678` and `"my-key-name"` with actual values that correspond to the AMI ID of your chosen Linux distribution and your EC2 key pair.

When running this program with Pulumi, it will provision the resources defined in the AWS cloud. To execute the deployment, you would run `pulumi up` in the terminal within the directory of the project after installing Pulumi and configuring AWS credentials.

The `pulumi.export` line is used to output the IDs of the created resources, which are useful for further referencing them outside of Pulumi, if necessary.