Add support for custom instance types

Custom instance types could previously only be set through setting
vcpu/memory/disk through the `configuration` block. As we deprecate
`configuration`, move setting vcpu, memory, and disk to the instance
type field of wrangler. By nature, this enforces that custom instance
types are mutually exclusive with the named instance types and will
allow us to remove a lot of the logic that verifies this once
`configuration` is removed.

Author: nikitassharma

.changeset/hungry-turtles-beam.md

@@ -0,0 +1,5 @@
+---
+"wrangler": patch
+---
+
+Add support for custom instance types

packages/wrangler/src/__tests__/cloudchamber/apply.test.ts

@@ -1614,6 +1614,63 @@ describe("cloudchamber apply", () => {
 		expect(std.stderr).toMatchInlineSnapshot(`""`);
 	});
 
+	test("can apply a simple application (custom instance type)", async () => {
+		setIsTTY(false);
+		writeWranglerConfig({
+			name: "my-container",
+			containers: [
+				{
+					name: "my-container-app",
+					instances: 3,
+					class_name: "DurableObjectClass",
+					instance_type: {
+						vcpu: 1,
+						memory_mib: 1024,
+						disk_mb: 2000,
+					},
+					image: "docker.io/beep:boop",
+					constraints: {
+						tier: 2,
+					},
+				},
+			],
+		});
+		mockGetApplications([]);
+		mockCreateApplication({ id: "abc" });
+		await runWrangler("cloudchamber apply");
+		expect(std.stdout).toMatchInlineSnapshot(`
+			"╭ Deploy a container application deploy changes to your application
+			│
+			│ Container application changes
+			│
+			├ NEW my-container-app
+			│
+			│   [[containers]]
+			│   name = \\"my-container-app\\"
+			│   instances = 3
+			│   scheduling_policy = \\"default\\"
+			│
+			│     [containers.constraints]
+			│     tier = 2
+			│
+			│     [containers.configuration]
+			│     image = \\"docker.io/beep:boop\\"
+			│     vcpu = 1
+			│     memory_mib = 1_024
+			│
+			│       [containers.configuration.disk]
+			│       size_mb = 2_000
+			│
+			│
+			│  SUCCESS  Created application my-container-app (Application ID: abc)
+			│
+			╰ Applied changes
+
+			"
+		`);
+		expect(std.stderr).toMatchInlineSnapshot(`""`);
+	});
+
 	test("can apply a simple existing application (instance type)", async () => {
 		setIsTTY(false);
 		writeWranglerConfig({
@@ -1691,6 +1748,96 @@ describe("cloudchamber apply", () => {
 		expect(app.configuration?.instance_type).toEqual("standard");
 	});
 
+	test("can apply a simple existing application (custom instance type)", async () => {
+		setIsTTY(false);
+		writeWranglerConfig({
+			name: "my-container",
+			containers: [
+				{
+					name: "my-container-app",
+					instances: 4,
+					class_name: "DurableObjectClass",
+					instance_type: {
+						vcpu: 1,
+						memory_mib: 1024,
+						disk_mb: 6000,
+					},
+					image: "docker.io/beep:boop",
+					constraints: {
+						tier: 2,
+					},
+				},
+			],
+		});
+		mockGetApplications([
+			{
+				id: "abc",
+				name: "my-container-app",
+				instances: 3,
+				created_at: new Date().toString(),
+				version: 1,
+				account_id: "1",
+				scheduling_policy: SchedulingPolicy.REGIONAL,
+				configuration: {
+					image: "docker.io/beep:boop",
+					disk: {
+						size: "2GB",
+						size_mb: 2000,
+					},
+					vcpu: 0.0625,
+					memory: "256MB",
+					memory_mib: 256,
+				},
+				constraints: {
+					tier: 3,
+				},
+			},
+		]);
+		const applicationReqBodyPromise = mockModifyApplication();
+		await runWrangler("cloudchamber apply");
+		expect(std.stdout).toMatchInlineSnapshot(`
+			"╭ Deploy a container application deploy changes to your application
+			│
+			│ Container application changes
+			│
+			├ EDIT my-container-app
+			│
+			│   [[containers]]
+			│ - instances = 3
+			│ + instances = 4
+			│   name = \\"my-container-app\\"
+			│   scheduling_policy = \\"regional\\"
+			│
+			│     [containers.configuration]
+			│     image = \\"docker.io/beep:boop\\"
+			│     memory = \\"256MB\\"
+			│ -   memory_mib = 256
+			│ +   memory_mib = 1_024
+			│
+			│ -   vcpu = 0.0625
+			│ +   vcpu = 1
+			│
+			│       [containers.configuration.disk]
+			│       size = \\"2GB\\"
+			│ -     size_mb = 2_000
+			│ +     size_mb = 6_000
+			│
+			│     [containers.constraints]
+			│ -   tier = 3
+			│ +   tier = 2
+			│
+			│
+			│  SUCCESS  Modified application my-container-app
+			│
+			╰ Applied changes
+
+			"
+		`);
+		expect(std.stderr).toMatchInlineSnapshot(`""`);
+		const app = await applicationReqBodyPromise;
+		expect(app.configuration?.instance_type).toBeUndefined();
+	});
+
 	test("falls back on dev instance type when instance type is absent", async () => {
 		setIsTTY(false);
 		writeWranglerConfig({

packages/wrangler/src/cloudchamber/apply.ts

@@ -188,22 +188,34 @@ function observabilityToConfiguration(
 
 function containerAppToInstanceType(
 	containerApp: ContainerApp
-): InstanceType | undefined {
+): Partial<UserDeploymentConfiguration> {
+	let configuration = (containerApp.configuration ??
+		{}) as Partial<UserDeploymentConfiguration>;
+
 	if (containerApp.instance_type !== undefined) {
-		return containerApp.instance_type as InstanceType;
+		if (typeof containerApp.instance_type === "string") {
+			return { instance_type: containerApp.instance_type as InstanceType };
+		}
+
+		configuration = {
+			vcpu: containerApp.instance_type.vcpu,
+			memory_mib: containerApp.instance_type.memory_mib,
+			disk: {
+				size_mb: containerApp.instance_type.disk_mb,
+			},
+		};
 	}
 
 	// if no other configuration is set, we fall back to the default "dev" instance type
-	const configuration =
-		containerApp.configuration as UserDeploymentConfiguration;
 	if (
-		configuration.disk === undefined &&
+		configuration.disk?.size_mb === undefined &&
 		configuration.vcpu === undefined &&
-		configuration.memory === undefined &&
 		configuration.memory_mib === undefined
 	) {
-		return InstanceType.DEV;
+		return { instance_type: InstanceType.DEV };
 	}
+
+	return configuration;
 }
 
 function containerAppToCreateApplication(
@@ -220,8 +232,8 @@ function containerAppToCreateApplication(
 	const instanceType = containerAppToInstanceType(containerApp);
 	const configuration: UserDeploymentConfiguration = {
 		...(containerApp.configuration as UserDeploymentConfiguration),
+		...instanceType,
 		observability: observabilityConfiguration,
-		instance_type: instanceType,
 	};
 
 	// this should have been set to a default value of worker-name-class-name if unspecified by the user

packages/wrangler/src/config/environment.ts

@@ -103,7 +103,15 @@ export type ContainerApp = {
 	 * @optional
 	 * @default "dev"
 	 */
-	instance_type?: "dev" | "basic" | "standard";
+	instance_type?:
+		| "dev"
+		| "basic"
+		| "standard"
+		| {
+				vcpu?: number;
+				memory_mib?: number;
+				disk_mb?: number;
+		  };
 
 	/**
 	 * @deprecated Use top level `containers` fields instead.

packages/wrangler/src/config/validation.ts

@@ -2428,13 +2428,13 @@ function validateContainerApp(
 				!containerAppOptional.image
 			) {
 				diagnostics.errors.push(
-					`"containers.image" field must be defined for each container app. This should be the path to your Dockerfile or a image URI pointing to the Cloudflare registry.`
+					`"containers.image" field must be defined for each container app. This should be the path to your Dockerfile or an image URI pointing to the Cloudflare registry.`
 				);
 			}
 
 			if ("configuration" in containerAppOptional) {
 				diagnostics.warnings.push(
-					`"containers.configuration" is deprecated. Use top level "containers" fields instead. "configuration.image" should be "image", "configuration.disk" should be set via "instance_type".`
+					`"containers.configuration" is deprecated. Use top level "containers" fields instead. "configuration.image" should be "image", limits should be set via "instance_type".`
 				);
 				if (
 					typeof containerAppOptional.configuration !== "object" ||
@@ -2509,14 +2509,6 @@ function validateContainerApp(
 				"string",
 				["full_auto", "full_manual", "none"]
 			);
-			validateOptionalProperty(
-				diagnostics,
-				field,
-				"instance_type",
-				containerAppOptional.instance_type,
-				"string",
-				["dev", "basic", "standard"]
-			);
 			validateOptionalProperty(
 				diagnostics,
 				field,
@@ -2589,6 +2581,56 @@ function validateContainerApp(
 					["image", "secrets", "labels", "disk", "vcpu", "memory_mib"]
 				);
 			}
+
+			// Instance Type validation: When present, the instance type should be either (1) a string
+			// representing a predefined instance type or (2) an object that optionally defines vcpu,
+			// memory, and disk.
+			//
+			// If an instance type is not set, a 'dev' instance type will be used. If a custom instance
+			// type doesn't set a value, that value will default to the corresponding value in a 'dev'
+			// instance type
+			if (typeof containerAppOptional.instance_type === "string") {
+				// validate named instance type
+				validateOptionalProperty(
+					diagnostics,
+					field,
+					"instance_type",
+					containerAppOptional.instance_type,
+					"string",
+					["dev", "basic", "standard"]
+				);
+			} else if (
+				validateOptionalProperty(
+					diagnostics,
+					field,
+					"instance_type",
+					containerAppOptional.instance_type,
+					"object"
+				) &&
+				containerAppOptional.instance_type
+			) {
+				// validate custom instance type
+				const instanceTypeProperties = ["vcpu", "memory_mib", "disk_mb"];
+				instanceTypeProperties.forEach((key) => {
+					if (
+						!isOptionalProperty(
+							containerAppOptional.instance_type,
+							key,
+							"number"
+						)
+					) {
+						diagnostics.errors.push(
+							`"containers.instance_type.${key}", when present, should be a number.`
+						);
+					}
+				});
+				validateAdditionalProperties(
+					diagnostics,
+					`${field}.instance_type`,
+					Object.keys(containerAppOptional.instance_type),
+					instanceTypeProperties
+				);
+			}
 		}
 
 		if (diagnostics.errors.length > 0) {