Subdomain Setup for AI Development Environments

Question

Pulumi · Accepted Answer

When setting up a subdomain for an AI development environment, you would typically use DNS and web services to configure and serve your application. Below, I'll provide a Pulumi program in Python that demonstrates how to create a subdomain in AWS using Route 53 for DNS management and an EC2 instance to serve as the AI development environment.

First, let me explain the process:

1. **Route 53 Hosted Zone**: you need a Route 53 hosted zone for your domain. This serves as the container for DNS settings for your domain.

2. **Route 53 Record**: within the hosted zone, you create a DNS record to map your subdomain to an IP address or another domain. In our case, we'll create an `A` record to point to the EC2 instance's IP address.

3. **EC2 Instance**: this is the virtual server where you will set up your AI development tools. You'll get a public IP when you launch an EC2 instance, which you'll use in the DNS record for routing to this server.

4. **Security Group**: this specifies the ports and protocols available to your EC2 instance. For a development environment, you would typically open ports like `22` for SSH, `80` for HTTP, and `443` for HTTPS.

Now, let's write the Pulumi program to automate this setup:

```python
import pulumi
import pulumi_aws as aws

# Create a VPC - necessary for launching an EC2 instance.
vpc = aws.ec2.Vpc("ai-dev-vpc", cidr_block="10.0.0.0/16")

# Create an Internet Gateway - allows communication between instances in your VPC and the internet.
igw = aws.ec2.InternetGateway("ai-dev-igw", vpc_id=vpc.id)

# Create a Route Table - rules for routing traffic from subnets to the internet.
route_table = aws.ec2.RouteTable("ai-dev-route-table", vpc_id=vpc.id,
                                 routes=[
                                     aws.ec2.RouteTableRouteArgs(
                                         cidr_block="0.0.0.0/0",
                                         gateway_id=igw.id
                                     )
                                 ])

# Create a Subnet - subdivisions of the VPC where you can launch AWS resources.
subnet = aws.ec2.Subnet("ai-dev-subnet", vpc_id=vpc.id, cidr_block="10.0.1.0/24")

# Associate the subnet with the route table to allow outbound traffic.
aws.ec2.RouteTableAssociation("ai-dev-rta", route_table_id=route_table.id, subnet_id=subnet.id)

# Create a Security Group - acts as a virtual firewall.
sec_group = aws.ec2.SecurityGroup("ai-dev-sec-group", vpc_id=vpc.id,
                                  ingress=[
                                      aws.ec2.SecurityGroupIngressArgs(
                                          protocol='tcp',
                                          from_port=22,
                                          to_port=22,
                                          cidr_blocks=["0.0.0.0/0"]
                                      ),
                                      aws.ec2.SecurityGroupIngressArgs(
                                          protocol='tcp',
                                          from_port=80,
                                          to_port=80,
                                          cidr_blocks=["0.0.0.0/0"]
                                      ),
                                      aws.ec2.SecurityGroupIngressArgs(
                                          protocol='tcp',
                                          from_port=443,
                                          to_port=443,
                                          cidr_blocks=["0.0.0.0/0"]
                                      ),
                                  ])

# Launch an EC2 instance - where your AI development environment will live.
ec2_instance = aws.ec2.Instance("ai-dev-instance",
                                instance_type="t2.micro",
                                vpc_security_group_ids=[sec_group.id],
                                ami="ami-0c55b159cbfafe1f0", # Replace this AMI with the one appropriate for your region
                                subnet_id=subnet.id)

# Assuming you have a domain registered through Route 53 and a hosted zone for it.
# Replace `mydomain.com` with your actual domain.
hosted_zone = aws.route53.get_zone(name="mydomain.com")

# Create a DNS record to point to the EC2 instance.
subdomain_record = aws.route53.Record("ai-dev-subdomain",
                                      zone_id=hosted_zone.zone_id,
                                      name="dev.mydomain.com", # Replace with your desired subdomain.
                                      type="A",
                                      ttl=300,
                                      records=[ec2_instance.public_ip])

# Export the public IP of the EC2 instance to access it.
pulumi.export("ec2_instance_public_ip", ec2_instance.public_ip)
pulumi.export("subdomain_dns_record", subdomain_record.fqdn)
```

Let's walk through this program:

- We begin by defining a new VPC and internet gateway required to launch an EC2 instance in AWS. These components structure the virtual network in which the instance exists.

- A `SecurityGroup` is set up next to define firewall rules. We allow inbound SSH, HTTP, and HTTPS traffic, which are typical for a development server.

- Then, we launch an `EC2 Instance` using the security group and the previously created VPC components.

- We use `Route53` to get the hosted zone for an existing domain (`mydomain.com` in this case) and create a DNS `A` record pointing to the EC2 instance's public IP. This establishes the subdomain we want for our AI development environment.

- The `pulumi.export` statements at the end reveal the public IP of the EC2 instance and the fully qualified domain name of the subdomain record once the program is deployed.

To use this code, replace `mydomain.com` with your actual domain name and `dev.mydomain.com` with your desired subdomain. Also, ensure the EC2 AMI ID (`ami-0c55b159cbfafe1f0` in this case) matches the one you want to use for your instance; this ID varies by region and instance type, so find the appropriate AMI from the AWS Management Console.

Deploying this code with Pulumi will create the described resources and configurations in your AWS account. Ensure you have AWS credentials configured on the machine where you run Pulumi, or set them via environment variables. Once deployed, you will have a new subdomain that points to your Amazon EC2 instance where you can set up your AI development tools.