AutoscalingPolicyArgs

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const asp = new gcp.dataproc.AutoscalingPolicy("asp", {
    policyId: "dataproc-policy",
    location: "us-central1",
    workerConfig: {
        maxInstances: 3,
    },
    basicAlgorithm: {
        yarnConfig: {
            gracefulDecommissionTimeout: "30s",
            scaleUpFactor: 0.5,
            scaleDownFactor: 0.5,
        },
    },
});
const basic = new gcp.dataproc.Cluster("basic", {
    name: "dataproc-policy",
    region: "us-central1",
    clusterConfig: {
        autoscalingConfig: {
            policyUri: asp.name,
        },
    },
});

import pulumi
import pulumi_gcp as gcp
asp = gcp.dataproc.AutoscalingPolicy("asp",
    policy_id="dataproc-policy",
    location="us-central1",
    worker_config={
        "max_instances": 3,
    },
    basic_algorithm={
        "yarn_config": {
            "graceful_decommission_timeout": "30s",
            "scale_up_factor": 0.5,
            "scale_down_factor": 0.5,
        },
    })
basic = gcp.dataproc.Cluster("basic",
    name="dataproc-policy",
    region="us-central1",
    cluster_config={
        "autoscaling_config": {
            "policy_uri": asp.name,
        },
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var asp = new Gcp.Dataproc.AutoscalingPolicy("asp", new()
    {
        PolicyId = "dataproc-policy",
        Location = "us-central1",
        WorkerConfig = new Gcp.Dataproc.Inputs.AutoscalingPolicyWorkerConfigArgs
        {
            MaxInstances = 3,
        },
        BasicAlgorithm = new Gcp.Dataproc.Inputs.AutoscalingPolicyBasicAlgorithmArgs
        {
            YarnConfig = new Gcp.Dataproc.Inputs.AutoscalingPolicyBasicAlgorithmYarnConfigArgs
            {
                GracefulDecommissionTimeout = "30s",
                ScaleUpFactor = 0.5,
                ScaleDownFactor = 0.5,
            },
        },
    });
    var basic = new Gcp.Dataproc.Cluster("basic", new()
    {
        Name = "dataproc-policy",
        Region = "us-central1",
        ClusterConfig = new Gcp.Dataproc.Inputs.ClusterClusterConfigArgs
        {
            AutoscalingConfig = new Gcp.Dataproc.Inputs.ClusterClusterConfigAutoscalingConfigArgs
            {
                PolicyUri = asp.Name,
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/dataproc"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		asp, err := dataproc.NewAutoscalingPolicy(ctx, "asp", &dataproc.AutoscalingPolicyArgs{
			PolicyId: pulumi.String("dataproc-policy"),
			Location: pulumi.String("us-central1"),
			WorkerConfig: &dataproc.AutoscalingPolicyWorkerConfigArgs{
				MaxInstances: pulumi.Int(3),
			},
			BasicAlgorithm: &dataproc.AutoscalingPolicyBasicAlgorithmArgs{
				YarnConfig: &dataproc.AutoscalingPolicyBasicAlgorithmYarnConfigArgs{
					GracefulDecommissionTimeout: pulumi.String("30s"),
					ScaleUpFactor:               pulumi.Float64(0.5),
					ScaleDownFactor:             pulumi.Float64(0.5),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = dataproc.NewCluster(ctx, "basic", &dataproc.ClusterArgs{
			Name:   pulumi.String("dataproc-policy"),
			Region: pulumi.String("us-central1"),
			ClusterConfig: &dataproc.ClusterClusterConfigArgs{
				AutoscalingConfig: &dataproc.ClusterClusterConfigAutoscalingConfigArgs{
					PolicyUri: asp.Name,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dataproc.AutoscalingPolicy;
import com.pulumi.gcp.dataproc.AutoscalingPolicyArgs;
import com.pulumi.gcp.dataproc.inputs.AutoscalingPolicyWorkerConfigArgs;
import com.pulumi.gcp.dataproc.inputs.AutoscalingPolicyBasicAlgorithmArgs;
import com.pulumi.gcp.dataproc.inputs.AutoscalingPolicyBasicAlgorithmYarnConfigArgs;
import com.pulumi.gcp.dataproc.Cluster;
import com.pulumi.gcp.dataproc.ClusterArgs;
import com.pulumi.gcp.dataproc.inputs.ClusterClusterConfigArgs;
import com.pulumi.gcp.dataproc.inputs.ClusterClusterConfigAutoscalingConfigArgs;
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 asp = new AutoscalingPolicy("asp", AutoscalingPolicyArgs.builder()
            .policyId("dataproc-policy")
            .location("us-central1")
            .workerConfig(AutoscalingPolicyWorkerConfigArgs.builder()
                .maxInstances(3)
                .build())
            .basicAlgorithm(AutoscalingPolicyBasicAlgorithmArgs.builder()
                .yarnConfig(AutoscalingPolicyBasicAlgorithmYarnConfigArgs.builder()
                    .gracefulDecommissionTimeout("30s")
                    .scaleUpFactor(0.5)
                    .scaleDownFactor(0.5)
                    .build())
                .build())
            .build());
        var basic = new Cluster("basic", ClusterArgs.builder()
            .name("dataproc-policy")
            .region("us-central1")
            .clusterConfig(ClusterClusterConfigArgs.builder()
                .autoscalingConfig(ClusterClusterConfigAutoscalingConfigArgs.builder()
                    .policyUri(asp.name())
                    .build())
                .build())
            .build());
    }
}

resources:
  basic:
    type: gcp:dataproc:Cluster
    properties:
      name: dataproc-policy
      region: us-central1
      clusterConfig:
        autoscalingConfig:
          policyUri: ${asp.name}
  asp:
    type: gcp:dataproc:AutoscalingPolicy
    properties:
      policyId: dataproc-policy
      location: us-central1
      workerConfig:
        maxInstances: 3
      basicAlgorithm:
        yarnConfig:
          gracefulDecommissionTimeout: 30s
          scaleUpFactor: 0.5
          scaleDownFactor: 0.5

$ pulumi import gcp:dataproc/autoscalingPolicy:AutoscalingPolicy default projects/{{project}}/locations/{{location}}/autoscalingPolicies/{{policy_id}}

$ pulumi import gcp:dataproc/autoscalingPolicy:AutoscalingPolicy default {{project}}/{{location}}/{{policy_id}}

$ pulumi import gcp:dataproc/autoscalingPolicy:AutoscalingPolicy default {{location}}/{{policy_id}}