Create AWS Cloud9 Development Environments

The aws:cloud9/environmentEC2:EnvironmentEC2 resource, part of the Pulumi AWS provider, provisions a Cloud9 EC2 Development Environment: a browser-based IDE backed by an EC2 instance. This guide focuses on three capabilities: instance type and AMI selection, console URL retrieval, and Elastic IP assignment.

Cloud9 environments run in a VPC and require IAM permissions for Cloud9 and EC2 operations. The examples are intentionally small. Combine them with your own VPC configuration, IAM roles, and network policies.

Create a Cloud9 environment with instance and AMI

Development teams provision Cloud9 environments to provide browser-based IDEs backed by EC2 instances.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.cloud9.EnvironmentEC2("example", {
    instanceType: "t2.micro",
    name: "example-env",
    imageId: "amazonlinux-2023-x86_64",
});

import pulumi
import pulumi_aws as aws

example = aws.cloud9.EnvironmentEC2("example",
    instance_type="t2.micro",
    name="example-env",
    image_id="amazonlinux-2023-x86_64")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloud9"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloud9.NewEnvironmentEC2(ctx, "example", &cloud9.EnvironmentEC2Args{
			InstanceType: pulumi.String("t2.micro"),
			Name:         pulumi.String("example-env"),
			ImageId:      pulumi.String("amazonlinux-2023-x86_64"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Cloud9.EnvironmentEC2("example", new()
    {
        InstanceType = "t2.micro",
        Name = "example-env",
        ImageId = "amazonlinux-2023-x86_64",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloud9.EnvironmentEC2;
import com.pulumi.aws.cloud9.EnvironmentEC2Args;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new EnvironmentEC2("example", EnvironmentEC2Args.builder()
            .instanceType("t2.micro")
            .name("example-env")
            .imageId("amazonlinux-2023-x86_64")
            .build());

    }
}

resources:
  example:
    type: aws:cloud9:EnvironmentEC2
    properties:
      instanceType: t2.micro
      name: example-env
      imageId: amazonlinux-2023-x86_64

The instanceType property sets the EC2 instance size (e.g., t2.micro for development). The imageId property selects the operating system; valid values include amazonlinux-2023-x86_64 and ubuntu-22.04-x86_64. Without a subnetId, the environment launches in your default VPC.

Retrieve the Cloud9 console URL after creation

After provisioning, teams often need to share the IDE URL with developers.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.cloud9.EnvironmentEC2("example", {instanceType: "t2.micro"});
const cloud9Instance = aws.ec2.getInstanceOutput({
    filters: [{
        name: "tag:aws:cloud9:environment",
        values: [example.id],
    }],
});
export const cloud9Url = pulumi.interpolate`https://${region}.console.aws.amazon.com/cloud9/ide/${example.id}`;

import pulumi
import pulumi_aws as aws

example = aws.cloud9.EnvironmentEC2("example", instance_type="t2.micro")
cloud9_instance = aws.ec2.get_instance_output(filters=[{
    "name": "tag:aws:cloud9:environment",
    "values": [example.id],
}])
pulumi.export("cloud9Url", example.id.apply(lambda id: f"https://{region}.console.aws.amazon.com/cloud9/ide/{id}"))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloud9"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := cloud9.NewEnvironmentEC2(ctx, "example", &cloud9.EnvironmentEC2Args{
			InstanceType: pulumi.String("t2.micro"),
		})
		if err != nil {
			return err
		}
		_ = ec2.LookupInstanceOutput(ctx, ec2.GetInstanceOutputArgs{
			Filters: ec2.GetInstanceFilterArray{
				&ec2.GetInstanceFilterArgs{
					Name: pulumi.String("tag:aws:cloud9:environment"),
					Values: pulumi.StringArray{
						example.ID(),
					},
				},
			},
		}, nil)
		ctx.Export("cloud9Url", example.ID().ApplyT(func(id string) (string, error) {
			return fmt.Sprintf("https://%v.console.aws.amazon.com/cloud9/ide/%v", region, id), nil
		}).(pulumi.StringOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Cloud9.EnvironmentEC2("example", new()
    {
        InstanceType = "t2.micro",
    });

    var cloud9Instance = Aws.Ec2.GetInstance.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetInstanceFilterInputArgs
            {
                Name = "tag:aws:cloud9:environment",
                Values = new[]
                {
                    example.Id,
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["cloud9Url"] = example.Id.Apply(id => $"https://{region}.console.aws.amazon.com/cloud9/ide/{id}"),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloud9.EnvironmentEC2;
import com.pulumi.aws.cloud9.EnvironmentEC2Args;
import com.pulumi.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetInstanceArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new EnvironmentEC2("example", EnvironmentEC2Args.builder()
            .instanceType("t2.micro")
            .build());

        final var cloud9Instance = Ec2Functions.getInstance(GetInstanceArgs.builder()
            .filters(GetInstanceFilterArgs.builder()
                .name("tag:aws:cloud9:environment")
                .values(example.id())
                .build())
            .build());

        ctx.export("cloud9Url", example.id().applyValue(_id -> String.format("https://%s.console.aws.amazon.com/cloud9/ide/%s", region,_id)));
    }
}

resources:
  example:
    type: aws:cloud9:EnvironmentEC2
    properties:
      instanceType: t2.micro
variables:
  cloud9Instance:
    fn::invoke:
      function: aws:ec2:getInstance
      arguments:
        filters:
          - name: tag:aws:cloud9:environment
            values:
              - ${example.id}
outputs:
  cloud9Url: https://${region}.console.aws.amazon.com/cloud9/ide/${example.id}

The environment’s id output identifies the Cloud9 environment. Use getInstanceOutput with a tag filter to find the backing EC2 instance. The interpolate function constructs the console URL from the region and environment ID, which you can share with team members.

Assign a static IP to the Cloud9 instance

Some workflows require stable IP addresses for firewall rules or external service integration.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.cloud9.EnvironmentEC2("example", {instanceType: "t2.micro"});
const cloud9Instance = aws.ec2.getInstanceOutput({
    filters: [{
        name: "tag:aws:cloud9:environment",
        values: [example.id],
    }],
});
const cloud9Eip = new aws.ec2.Eip("cloud9_eip", {
    instance: cloud9Instance.apply(cloud9Instance => cloud9Instance.id),
    domain: "vpc",
});
export const cloud9PublicIp = cloud9Eip.publicIp;

import pulumi
import pulumi_aws as aws

example = aws.cloud9.EnvironmentEC2("example", instance_type="t2.micro")
cloud9_instance = aws.ec2.get_instance_output(filters=[{
    "name": "tag:aws:cloud9:environment",
    "values": [example.id],
}])
cloud9_eip = aws.ec2.Eip("cloud9_eip",
    instance=cloud9_instance.id,
    domain="vpc")
pulumi.export("cloud9PublicIp", cloud9_eip.public_ip)

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloud9"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := cloud9.NewEnvironmentEC2(ctx, "example", &cloud9.EnvironmentEC2Args{
			InstanceType: pulumi.String("t2.micro"),
		})
		if err != nil {
			return err
		}
		cloud9Instance := ec2.LookupInstanceOutput(ctx, ec2.GetInstanceOutputArgs{
			Filters: ec2.GetInstanceFilterArray{
				&ec2.GetInstanceFilterArgs{
					Name: pulumi.String("tag:aws:cloud9:environment"),
					Values: pulumi.StringArray{
						example.ID(),
					},
				},
			},
		}, nil)
		cloud9Eip, err := ec2.NewEip(ctx, "cloud9_eip", &ec2.EipArgs{
			Instance: pulumi.String(cloud9Instance.ApplyT(func(cloud9Instance ec2.GetInstanceResult) (*string, error) {
				return &cloud9Instance.Id, nil
			}).(pulumi.StringPtrOutput)),
			Domain: pulumi.String("vpc"),
		})
		if err != nil {
			return err
		}
		ctx.Export("cloud9PublicIp", cloud9Eip.PublicIp)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Cloud9.EnvironmentEC2("example", new()
    {
        InstanceType = "t2.micro",
    });

    var cloud9Instance = Aws.Ec2.GetInstance.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetInstanceFilterInputArgs
            {
                Name = "tag:aws:cloud9:environment",
                Values = new[]
                {
                    example.Id,
                },
            },
        },
    });

    var cloud9Eip = new Aws.Ec2.Eip("cloud9_eip", new()
    {
        Instance = cloud9Instance.Apply(getInstanceResult => getInstanceResult.Id),
        Domain = "vpc",
    });

    return new Dictionary<string, object?>
    {
        ["cloud9PublicIp"] = cloud9Eip.PublicIp,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloud9.EnvironmentEC2;
import com.pulumi.aws.cloud9.EnvironmentEC2Args;
import com.pulumi.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetInstanceArgs;
import com.pulumi.aws.ec2.Eip;
import com.pulumi.aws.ec2.EipArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new EnvironmentEC2("example", EnvironmentEC2Args.builder()
            .instanceType("t2.micro")
            .build());

        final var cloud9Instance = Ec2Functions.getInstance(GetInstanceArgs.builder()
            .filters(GetInstanceFilterArgs.builder()
                .name("tag:aws:cloud9:environment")
                .values(example.id())
                .build())
            .build());

        var cloud9Eip = new Eip("cloud9Eip", EipArgs.builder()
            .instance(cloud9Instance.applyValue(_cloud9Instance -> _cloud9Instance.id()))
            .domain("vpc")
            .build());

        ctx.export("cloud9PublicIp", cloud9Eip.publicIp());
    }
}

resources:
  example:
    type: aws:cloud9:EnvironmentEC2
    properties:
      instanceType: t2.micro
  cloud9Eip:
    type: aws:ec2:Eip
    name: cloud9_eip
    properties:
      instance: ${cloud9Instance.id}
      domain: vpc
variables:
  cloud9Instance:
    fn::invoke:
      function: aws:ec2:getInstance
      arguments:
        filters:
          - name: tag:aws:cloud9:environment
            values:
              - ${example.id}
outputs:
  cloud9PublicIp: ${cloud9Eip.publicIp}

After creating the environment, look up the backing EC2 instance using the same tag filter pattern. Create an Elastic IP with domain set to “vpc” and attach it to the instance. The publicIp output provides the stable address for firewall rules or external access.

Beyond these examples

These snippets focus on specific Cloud9 environment features: instance type and AMI selection, console URL construction, and Elastic IP assignment. They’re intentionally minimal rather than full development environment deployments.

The examples rely on pre-existing infrastructure such as the default VPC (or explicit subnet if using subnetId) and IAM permissions for Cloud9 and EC2. They focus on configuring the environment rather than provisioning surrounding infrastructure.

To keep things focused, common environment patterns are omitted, including:

VPC placement (subnetId for private subnets)
Connection type (CONNECT_SSH vs CONNECT_SSM)
Auto-stop timing (automaticStopTimeMinutes)
Owner assignment (ownerArn for shared environments)

These omissions are intentional: the goal is to illustrate how each Cloud9 feature is wired, not provide drop-in development environment modules. See the Cloud9 EnvironmentEC2 resource reference for all available configuration options.

Let's create AWS Cloud9 Development Environments

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration & Setup

What are the required properties to create a Cloud9 environment?

You must specify imageId, instanceType, name, ownerArn, and region. The ownerArn defaults to the environment’s creator if not provided.

What AMI images can I use for Cloud9 environments?

Valid imageId values include amazonlinux-2-x86_64, amazonlinux-2023-x86_64, ubuntu-18.04-x86_64, ubuntu-22.04-x86_64, and their SSM parameter equivalents like resolve:ssm:/aws/service/cloud9/amis/amazonlinux-2023-x86_64.

What connection types are available for Cloud9 environments?

Cloud9 supports two connection types: CONNECT_SSH and CONNECT_SSM. This property is immutable after creation.

Immutability & Updates

What properties can't be changed after creating a Cloud9 environment?

The following properties are immutable and require environment replacement if changed: imageId, instanceType, ownerArn, automaticStopTimeMinutes, connectionType, and subnetId.

Networking & Access

How do I get the URL to access my Cloud9 IDE?

Construct the URL using the environment ID: https://{region}.console.aws.amazon.com/cloud9/ide/{environment.id}.

Can I assign a static IP address to my Cloud9 environment?

Yes, allocate an Elastic IP to the underlying EC2 instance. Use aws.ec2.getInstance with a filter on tag aws:cloud9:environment matching the environment ID, then attach the EIP to that instance.

How do I find the EC2 instance backing my Cloud9 environment?

Use aws.ec2.getInstance with a filter on tag name aws:cloud9:environment and the environment ID as the value.

Using a different cloud?

Explore compute guides for other cloud providers:

Azure Guides GCP Guides