1. Packages
  2. Rancher2 Provider
  3. API Docs
  4. ClusterSync
Rancher 2 v8.0.0 published on Wednesday, Dec 4, 2024 by Pulumi

rancher2.ClusterSync

Explore with Pulumi AI

rancher2 logo
Rancher 2 v8.0.0 published on Wednesday, Dec 4, 2024 by Pulumi

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as rancher2 from "@pulumi/rancher2";
    
    // Create a new rancher2 rke Cluster 
    const foo_custom = new rancher2.Cluster("foo-custom", {
        name: "foo-custom",
        description: "Foo rancher2 custom cluster",
        rkeConfig: {
            network: {
                plugin: "canal",
            },
        },
    });
    // Create a new rancher2 Node Template
    const foo = new rancher2.NodeTemplate("foo", {
        name: "foo",
        description: "foo test",
        amazonec2Config: {
            accessKey: "<AWS_ACCESS_KEY>",
            secretKey: "<AWS_SECRET_KEY>",
            ami: "<AMI_ID>",
            region: "<REGION>",
            securityGroups: ["<AWS_SECURITY_GROUP>"],
            subnetId: "<SUBNET_ID>",
            vpcId: "<VPC_ID>",
            zone: "<ZONE>",
        },
    });
    // Create a new rancher2 Node Pool
    const fooNodePool = new rancher2.NodePool("foo", {
        clusterId: foo_custom.id,
        name: "foo",
        hostnamePrefix: "foo-cluster-0",
        nodeTemplateId: foo.id,
        quantity: 3,
        controlPlane: true,
        etcd: true,
        worker: true,
    });
    // Create a new rancher2 Cluster Sync
    const foo_customClusterSync = new rancher2.ClusterSync("foo-custom", {
        clusterId: foo_custom.id,
        nodePoolIds: [fooNodePool.id],
    });
    // Create a new rancher2 Project
    const fooProject = new rancher2.Project("foo", {
        name: "foo",
        clusterId: foo_customClusterSync.id,
        description: "Terraform namespace acceptance test",
        resourceQuota: {
            projectLimit: {
                limitsCpu: "2000m",
                limitsMemory: "2000Mi",
                requestsStorage: "2Gi",
            },
            namespaceDefaultLimit: {
                limitsCpu: "500m",
                limitsMemory: "500Mi",
                requestsStorage: "1Gi",
            },
        },
        containerResourceLimit: {
            limitsCpu: "20m",
            limitsMemory: "20Mi",
            requestsCpu: "1m",
            requestsMemory: "1Mi",
        },
    });
    
    import pulumi
    import pulumi_rancher2 as rancher2
    
    # Create a new rancher2 rke Cluster 
    foo_custom = rancher2.Cluster("foo-custom",
        name="foo-custom",
        description="Foo rancher2 custom cluster",
        rke_config={
            "network": {
                "plugin": "canal",
            },
        })
    # Create a new rancher2 Node Template
    foo = rancher2.NodeTemplate("foo",
        name="foo",
        description="foo test",
        amazonec2_config={
            "access_key": "<AWS_ACCESS_KEY>",
            "secret_key": "<AWS_SECRET_KEY>",
            "ami": "<AMI_ID>",
            "region": "<REGION>",
            "security_groups": ["<AWS_SECURITY_GROUP>"],
            "subnet_id": "<SUBNET_ID>",
            "vpc_id": "<VPC_ID>",
            "zone": "<ZONE>",
        })
    # Create a new rancher2 Node Pool
    foo_node_pool = rancher2.NodePool("foo",
        cluster_id=foo_custom.id,
        name="foo",
        hostname_prefix="foo-cluster-0",
        node_template_id=foo.id,
        quantity=3,
        control_plane=True,
        etcd=True,
        worker=True)
    # Create a new rancher2 Cluster Sync
    foo_custom_cluster_sync = rancher2.ClusterSync("foo-custom",
        cluster_id=foo_custom.id,
        node_pool_ids=[foo_node_pool.id])
    # Create a new rancher2 Project
    foo_project = rancher2.Project("foo",
        name="foo",
        cluster_id=foo_custom_cluster_sync.id,
        description="Terraform namespace acceptance test",
        resource_quota={
            "project_limit": {
                "limits_cpu": "2000m",
                "limits_memory": "2000Mi",
                "requests_storage": "2Gi",
            },
            "namespace_default_limit": {
                "limits_cpu": "500m",
                "limits_memory": "500Mi",
                "requests_storage": "1Gi",
            },
        },
        container_resource_limit={
            "limits_cpu": "20m",
            "limits_memory": "20Mi",
            "requests_cpu": "1m",
            "requests_memory": "1Mi",
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-rancher2/sdk/v8/go/rancher2"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// Create a new rancher2 rke Cluster
    		_, err := rancher2.NewCluster(ctx, "foo-custom", &rancher2.ClusterArgs{
    			Name:        pulumi.String("foo-custom"),
    			Description: pulumi.String("Foo rancher2 custom cluster"),
    			RkeConfig: &rancher2.ClusterRkeConfigArgs{
    				Network: &rancher2.ClusterRkeConfigNetworkArgs{
    					Plugin: pulumi.String("canal"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Create a new rancher2 Node Template
    		foo, err := rancher2.NewNodeTemplate(ctx, "foo", &rancher2.NodeTemplateArgs{
    			Name:        pulumi.String("foo"),
    			Description: pulumi.String("foo test"),
    			Amazonec2Config: &rancher2.NodeTemplateAmazonec2ConfigArgs{
    				AccessKey: pulumi.String("<AWS_ACCESS_KEY>"),
    				SecretKey: pulumi.String("<AWS_SECRET_KEY>"),
    				Ami:       pulumi.String("<AMI_ID>"),
    				Region:    pulumi.String("<REGION>"),
    				SecurityGroups: pulumi.StringArray{
    					pulumi.String("<AWS_SECURITY_GROUP>"),
    				},
    				SubnetId: pulumi.String("<SUBNET_ID>"),
    				VpcId:    pulumi.String("<VPC_ID>"),
    				Zone:     pulumi.String("<ZONE>"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Create a new rancher2 Node Pool
    		fooNodePool, err := rancher2.NewNodePool(ctx, "foo", &rancher2.NodePoolArgs{
    			ClusterId:      foo_custom.ID(),
    			Name:           pulumi.String("foo"),
    			HostnamePrefix: pulumi.String("foo-cluster-0"),
    			NodeTemplateId: foo.ID(),
    			Quantity:       pulumi.Int(3),
    			ControlPlane:   pulumi.Bool(true),
    			Etcd:           pulumi.Bool(true),
    			Worker:         pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		// Create a new rancher2 Cluster Sync
    		_, err = rancher2.NewClusterSync(ctx, "foo-custom", &rancher2.ClusterSyncArgs{
    			ClusterId: foo_custom.ID(),
    			NodePoolIds: pulumi.StringArray{
    				fooNodePool.ID(),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Create a new rancher2 Project
    		_, err = rancher2.NewProject(ctx, "foo", &rancher2.ProjectArgs{
    			Name:        pulumi.String("foo"),
    			ClusterId:   foo_customClusterSync.ID(),
    			Description: pulumi.String("Terraform namespace acceptance test"),
    			ResourceQuota: &rancher2.ProjectResourceQuotaArgs{
    				ProjectLimit: &rancher2.ProjectResourceQuotaProjectLimitArgs{
    					LimitsCpu:       pulumi.String("2000m"),
    					LimitsMemory:    pulumi.String("2000Mi"),
    					RequestsStorage: pulumi.String("2Gi"),
    				},
    				NamespaceDefaultLimit: &rancher2.ProjectResourceQuotaNamespaceDefaultLimitArgs{
    					LimitsCpu:       pulumi.String("500m"),
    					LimitsMemory:    pulumi.String("500Mi"),
    					RequestsStorage: pulumi.String("1Gi"),
    				},
    			},
    			ContainerResourceLimit: &rancher2.ProjectContainerResourceLimitArgs{
    				LimitsCpu:      pulumi.String("20m"),
    				LimitsMemory:   pulumi.String("20Mi"),
    				RequestsCpu:    pulumi.String("1m"),
    				RequestsMemory: pulumi.String("1Mi"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Rancher2 = Pulumi.Rancher2;
    
    return await Deployment.RunAsync(() => 
    {
        // Create a new rancher2 rke Cluster 
        var foo_custom = new Rancher2.Cluster("foo-custom", new()
        {
            Name = "foo-custom",
            Description = "Foo rancher2 custom cluster",
            RkeConfig = new Rancher2.Inputs.ClusterRkeConfigArgs
            {
                Network = new Rancher2.Inputs.ClusterRkeConfigNetworkArgs
                {
                    Plugin = "canal",
                },
            },
        });
    
        // Create a new rancher2 Node Template
        var foo = new Rancher2.NodeTemplate("foo", new()
        {
            Name = "foo",
            Description = "foo test",
            Amazonec2Config = new Rancher2.Inputs.NodeTemplateAmazonec2ConfigArgs
            {
                AccessKey = "<AWS_ACCESS_KEY>",
                SecretKey = "<AWS_SECRET_KEY>",
                Ami = "<AMI_ID>",
                Region = "<REGION>",
                SecurityGroups = new[]
                {
                    "<AWS_SECURITY_GROUP>",
                },
                SubnetId = "<SUBNET_ID>",
                VpcId = "<VPC_ID>",
                Zone = "<ZONE>",
            },
        });
    
        // Create a new rancher2 Node Pool
        var fooNodePool = new Rancher2.NodePool("foo", new()
        {
            ClusterId = foo_custom.Id,
            Name = "foo",
            HostnamePrefix = "foo-cluster-0",
            NodeTemplateId = foo.Id,
            Quantity = 3,
            ControlPlane = true,
            Etcd = true,
            Worker = true,
        });
    
        // Create a new rancher2 Cluster Sync
        var foo_customClusterSync = new Rancher2.ClusterSync("foo-custom", new()
        {
            ClusterId = foo_custom.Id,
            NodePoolIds = new[]
            {
                fooNodePool.Id,
            },
        });
    
        // Create a new rancher2 Project
        var fooProject = new Rancher2.Project("foo", new()
        {
            Name = "foo",
            ClusterId = foo_customClusterSync.Id,
            Description = "Terraform namespace acceptance test",
            ResourceQuota = new Rancher2.Inputs.ProjectResourceQuotaArgs
            {
                ProjectLimit = new Rancher2.Inputs.ProjectResourceQuotaProjectLimitArgs
                {
                    LimitsCpu = "2000m",
                    LimitsMemory = "2000Mi",
                    RequestsStorage = "2Gi",
                },
                NamespaceDefaultLimit = new Rancher2.Inputs.ProjectResourceQuotaNamespaceDefaultLimitArgs
                {
                    LimitsCpu = "500m",
                    LimitsMemory = "500Mi",
                    RequestsStorage = "1Gi",
                },
            },
            ContainerResourceLimit = new Rancher2.Inputs.ProjectContainerResourceLimitArgs
            {
                LimitsCpu = "20m",
                LimitsMemory = "20Mi",
                RequestsCpu = "1m",
                RequestsMemory = "1Mi",
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.rancher2.Cluster;
    import com.pulumi.rancher2.ClusterArgs;
    import com.pulumi.rancher2.inputs.ClusterRkeConfigArgs;
    import com.pulumi.rancher2.inputs.ClusterRkeConfigNetworkArgs;
    import com.pulumi.rancher2.NodeTemplate;
    import com.pulumi.rancher2.NodeTemplateArgs;
    import com.pulumi.rancher2.inputs.NodeTemplateAmazonec2ConfigArgs;
    import com.pulumi.rancher2.NodePool;
    import com.pulumi.rancher2.NodePoolArgs;
    import com.pulumi.rancher2.ClusterSync;
    import com.pulumi.rancher2.ClusterSyncArgs;
    import com.pulumi.rancher2.Project;
    import com.pulumi.rancher2.ProjectArgs;
    import com.pulumi.rancher2.inputs.ProjectResourceQuotaArgs;
    import com.pulumi.rancher2.inputs.ProjectResourceQuotaProjectLimitArgs;
    import com.pulumi.rancher2.inputs.ProjectResourceQuotaNamespaceDefaultLimitArgs;
    import com.pulumi.rancher2.inputs.ProjectContainerResourceLimitArgs;
    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) {
            // Create a new rancher2 rke Cluster 
            var foo_custom = new Cluster("foo-custom", ClusterArgs.builder()
                .name("foo-custom")
                .description("Foo rancher2 custom cluster")
                .rkeConfig(ClusterRkeConfigArgs.builder()
                    .network(ClusterRkeConfigNetworkArgs.builder()
                        .plugin("canal")
                        .build())
                    .build())
                .build());
    
            // Create a new rancher2 Node Template
            var foo = new NodeTemplate("foo", NodeTemplateArgs.builder()
                .name("foo")
                .description("foo test")
                .amazonec2Config(NodeTemplateAmazonec2ConfigArgs.builder()
                    .accessKey("<AWS_ACCESS_KEY>")
                    .secretKey("<AWS_SECRET_KEY>")
                    .ami("<AMI_ID>")
                    .region("<REGION>")
                    .securityGroups("<AWS_SECURITY_GROUP>")
                    .subnetId("<SUBNET_ID>")
                    .vpcId("<VPC_ID>")
                    .zone("<ZONE>")
                    .build())
                .build());
    
            // Create a new rancher2 Node Pool
            var fooNodePool = new NodePool("fooNodePool", NodePoolArgs.builder()
                .clusterId(foo_custom.id())
                .name("foo")
                .hostnamePrefix("foo-cluster-0")
                .nodeTemplateId(foo.id())
                .quantity(3)
                .controlPlane(true)
                .etcd(true)
                .worker(true)
                .build());
    
            // Create a new rancher2 Cluster Sync
            var foo_customClusterSync = new ClusterSync("foo-customClusterSync", ClusterSyncArgs.builder()
                .clusterId(foo_custom.id())
                .nodePoolIds(fooNodePool.id())
                .build());
    
            // Create a new rancher2 Project
            var fooProject = new Project("fooProject", ProjectArgs.builder()
                .name("foo")
                .clusterId(foo_customClusterSync.id())
                .description("Terraform namespace acceptance test")
                .resourceQuota(ProjectResourceQuotaArgs.builder()
                    .projectLimit(ProjectResourceQuotaProjectLimitArgs.builder()
                        .limitsCpu("2000m")
                        .limitsMemory("2000Mi")
                        .requestsStorage("2Gi")
                        .build())
                    .namespaceDefaultLimit(ProjectResourceQuotaNamespaceDefaultLimitArgs.builder()
                        .limitsCpu("500m")
                        .limitsMemory("500Mi")
                        .requestsStorage("1Gi")
                        .build())
                    .build())
                .containerResourceLimit(ProjectContainerResourceLimitArgs.builder()
                    .limitsCpu("20m")
                    .limitsMemory("20Mi")
                    .requestsCpu("1m")
                    .requestsMemory("1Mi")
                    .build())
                .build());
    
        }
    }
    
    resources:
      # Create a new rancher2 rke Cluster
      foo-custom:
        type: rancher2:Cluster
        properties:
          name: foo-custom
          description: Foo rancher2 custom cluster
          rkeConfig:
            network:
              plugin: canal
      # Create a new rancher2 Node Template
      foo:
        type: rancher2:NodeTemplate
        properties:
          name: foo
          description: foo test
          amazonec2Config:
            accessKey: <AWS_ACCESS_KEY>
            secretKey: <AWS_SECRET_KEY>
            ami: <AMI_ID>
            region: <REGION>
            securityGroups:
              - <AWS_SECURITY_GROUP>
            subnetId: <SUBNET_ID>
            vpcId: <VPC_ID>
            zone: <ZONE>
      # Create a new rancher2 Node Pool
      fooNodePool:
        type: rancher2:NodePool
        name: foo
        properties:
          clusterId: ${["foo-custom"].id}
          name: foo
          hostnamePrefix: foo-cluster-0
          nodeTemplateId: ${foo.id}
          quantity: 3
          controlPlane: true
          etcd: true
          worker: true
      # Create a new rancher2 Cluster Sync
      foo-customClusterSync:
        type: rancher2:ClusterSync
        name: foo-custom
        properties:
          clusterId: ${["foo-custom"].id}
          nodePoolIds:
            - ${fooNodePool.id}
      # Create a new rancher2 Project
      fooProject:
        type: rancher2:Project
        name: foo
        properties:
          name: foo
          clusterId: ${["foo-customClusterSync"].id}
          description: Terraform namespace acceptance test
          resourceQuota:
            projectLimit:
              limitsCpu: 2000m
              limitsMemory: 2000Mi
              requestsStorage: 2Gi
            namespaceDefaultLimit:
              limitsCpu: 500m
              limitsMemory: 500Mi
              requestsStorage: 1Gi
          containerResourceLimit:
            limitsCpu: 20m
            limitsMemory: 20Mi
            requestsCpu: 1m
            requestsMemory: 1Mi
    

    Create ClusterSync Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new ClusterSync(name: string, args: ClusterSyncArgs, opts?: CustomResourceOptions);
    @overload
    def ClusterSync(resource_name: str,
                    args: ClusterSyncArgs,
                    opts: Optional[ResourceOptions] = None)
    
    @overload
    def ClusterSync(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    cluster_id: Optional[str] = None,
                    node_pool_ids: Optional[Sequence[str]] = None,
                    state_confirm: Optional[int] = None,
                    synced: Optional[bool] = None,
                    wait_catalogs: Optional[bool] = None)
    func NewClusterSync(ctx *Context, name string, args ClusterSyncArgs, opts ...ResourceOption) (*ClusterSync, error)
    public ClusterSync(string name, ClusterSyncArgs args, CustomResourceOptions? opts = null)
    public ClusterSync(String name, ClusterSyncArgs args)
    public ClusterSync(String name, ClusterSyncArgs args, CustomResourceOptions options)
    
    type: rancher2:ClusterSync
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args ClusterSyncArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ClusterSyncArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ClusterSyncArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ClusterSyncArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ClusterSyncArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var clusterSyncResource = new Rancher2.ClusterSync("clusterSyncResource", new()
    {
        ClusterId = "string",
        NodePoolIds = new[]
        {
            "string",
        },
        StateConfirm = 0,
        Synced = false,
        WaitCatalogs = false,
    });
    
    example, err := rancher2.NewClusterSync(ctx, "clusterSyncResource", &rancher2.ClusterSyncArgs{
    	ClusterId: pulumi.String("string"),
    	NodePoolIds: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	StateConfirm: pulumi.Int(0),
    	Synced:       pulumi.Bool(false),
    	WaitCatalogs: pulumi.Bool(false),
    })
    
    var clusterSyncResource = new ClusterSync("clusterSyncResource", ClusterSyncArgs.builder()
        .clusterId("string")
        .nodePoolIds("string")
        .stateConfirm(0)
        .synced(false)
        .waitCatalogs(false)
        .build());
    
    cluster_sync_resource = rancher2.ClusterSync("clusterSyncResource",
        cluster_id="string",
        node_pool_ids=["string"],
        state_confirm=0,
        synced=False,
        wait_catalogs=False)
    
    const clusterSyncResource = new rancher2.ClusterSync("clusterSyncResource", {
        clusterId: "string",
        nodePoolIds: ["string"],
        stateConfirm: 0,
        synced: false,
        waitCatalogs: false,
    });
    
    type: rancher2:ClusterSync
    properties:
        clusterId: string
        nodePoolIds:
            - string
        stateConfirm: 0
        synced: false
        waitCatalogs: false
    

    ClusterSync Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The ClusterSync resource accepts the following input properties:

    ClusterId string
    The cluster ID that is syncing (string)
    NodePoolIds List<string>
    The node pool IDs used by the cluster id (list)
    StateConfirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    Synced bool
    WaitCatalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    ClusterId string
    The cluster ID that is syncing (string)
    NodePoolIds []string
    The node pool IDs used by the cluster id (list)
    StateConfirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    Synced bool
    WaitCatalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId String
    The cluster ID that is syncing (string)
    nodePoolIds List<String>
    The node pool IDs used by the cluster id (list)
    stateConfirm Integer

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced Boolean
    waitCatalogs Boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId string
    The cluster ID that is syncing (string)
    nodePoolIds string[]
    The node pool IDs used by the cluster id (list)
    stateConfirm number

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced boolean
    waitCatalogs boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)
    cluster_id str
    The cluster ID that is syncing (string)
    node_pool_ids Sequence[str]
    The node pool IDs used by the cluster id (list)
    state_confirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced bool
    wait_catalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId String
    The cluster ID that is syncing (string)
    nodePoolIds List<String>
    The node pool IDs used by the cluster id (list)
    stateConfirm Number

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced Boolean
    waitCatalogs Boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)

    Outputs

    All input properties are implicitly available as output properties. Additionally, the ClusterSync resource produces the following output properties:

    DefaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    Id string
    The provider-assigned unique ID for this managed resource.
    KubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    Nodes List<ClusterSyncNode>
    (Computed) The cluster nodes (list).
    SystemProjectId string
    (Computed) System project ID for the cluster sync (string)
    DefaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    Id string
    The provider-assigned unique ID for this managed resource.
    KubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    Nodes []ClusterSyncNode
    (Computed) The cluster nodes (list).
    SystemProjectId string
    (Computed) System project ID for the cluster sync (string)
    defaultProjectId String
    (Computed) Default project ID for the cluster sync (string)
    id String
    The provider-assigned unique ID for this managed resource.
    kubeConfig String
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodes List<ClusterSyncNode>
    (Computed) The cluster nodes (list).
    systemProjectId String
    (Computed) System project ID for the cluster sync (string)
    defaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    id string
    The provider-assigned unique ID for this managed resource.
    kubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodes ClusterSyncNode[]
    (Computed) The cluster nodes (list).
    systemProjectId string
    (Computed) System project ID for the cluster sync (string)
    default_project_id str
    (Computed) Default project ID for the cluster sync (string)
    id str
    The provider-assigned unique ID for this managed resource.
    kube_config str
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodes Sequence[ClusterSyncNode]
    (Computed) The cluster nodes (list).
    system_project_id str
    (Computed) System project ID for the cluster sync (string)
    defaultProjectId String
    (Computed) Default project ID for the cluster sync (string)
    id String
    The provider-assigned unique ID for this managed resource.
    kubeConfig String
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodes List<Property Map>
    (Computed) The cluster nodes (list).
    systemProjectId String
    (Computed) System project ID for the cluster sync (string)

    Look up Existing ClusterSync Resource

    Get an existing ClusterSync resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ClusterSyncState, opts?: CustomResourceOptions): ClusterSync
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            cluster_id: Optional[str] = None,
            default_project_id: Optional[str] = None,
            kube_config: Optional[str] = None,
            node_pool_ids: Optional[Sequence[str]] = None,
            nodes: Optional[Sequence[ClusterSyncNodeArgs]] = None,
            state_confirm: Optional[int] = None,
            synced: Optional[bool] = None,
            system_project_id: Optional[str] = None,
            wait_catalogs: Optional[bool] = None) -> ClusterSync
    func GetClusterSync(ctx *Context, name string, id IDInput, state *ClusterSyncState, opts ...ResourceOption) (*ClusterSync, error)
    public static ClusterSync Get(string name, Input<string> id, ClusterSyncState? state, CustomResourceOptions? opts = null)
    public static ClusterSync get(String name, Output<String> id, ClusterSyncState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ClusterId string
    The cluster ID that is syncing (string)
    DefaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    KubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    NodePoolIds List<string>
    The node pool IDs used by the cluster id (list)
    Nodes List<ClusterSyncNode>
    (Computed) The cluster nodes (list).
    StateConfirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    Synced bool
    SystemProjectId string
    (Computed) System project ID for the cluster sync (string)
    WaitCatalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    ClusterId string
    The cluster ID that is syncing (string)
    DefaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    KubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    NodePoolIds []string
    The node pool IDs used by the cluster id (list)
    Nodes []ClusterSyncNodeArgs
    (Computed) The cluster nodes (list).
    StateConfirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    Synced bool
    SystemProjectId string
    (Computed) System project ID for the cluster sync (string)
    WaitCatalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId String
    The cluster ID that is syncing (string)
    defaultProjectId String
    (Computed) Default project ID for the cluster sync (string)
    kubeConfig String
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodePoolIds List<String>
    The node pool IDs used by the cluster id (list)
    nodes List<ClusterSyncNode>
    (Computed) The cluster nodes (list).
    stateConfirm Integer

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced Boolean
    systemProjectId String
    (Computed) System project ID for the cluster sync (string)
    waitCatalogs Boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId string
    The cluster ID that is syncing (string)
    defaultProjectId string
    (Computed) Default project ID for the cluster sync (string)
    kubeConfig string
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodePoolIds string[]
    The node pool IDs used by the cluster id (list)
    nodes ClusterSyncNode[]
    (Computed) The cluster nodes (list).
    stateConfirm number

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced boolean
    systemProjectId string
    (Computed) System project ID for the cluster sync (string)
    waitCatalogs boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)
    cluster_id str
    The cluster ID that is syncing (string)
    default_project_id str
    (Computed) Default project ID for the cluster sync (string)
    kube_config str
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    node_pool_ids Sequence[str]
    The node pool IDs used by the cluster id (list)
    nodes Sequence[ClusterSyncNodeArgs]
    (Computed) The cluster nodes (list).
    state_confirm int

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced bool
    system_project_id str
    (Computed) System project ID for the cluster sync (string)
    wait_catalogs bool
    Wait until all catalogs are downloaded and active. Default: false (bool)
    clusterId String
    The cluster ID that is syncing (string)
    defaultProjectId String
    (Computed) Default project ID for the cluster sync (string)
    kubeConfig String
    (Computed/Sensitive) Kube Config generated for the cluster sync (string)
    nodePoolIds List<String>
    The node pool IDs used by the cluster id (list)
    nodes List<Property Map>
    (Computed) The cluster nodes (list).
    stateConfirm Number

    Wait until active status is confirmed a number of times (wait interval of 5s). Default: 1 means no confirmation (int)

    Note: state_confirm would be useful, if you have troubles for creating/updating custom clusters that eventually are reaching active state before they are fully installed. For example: setting state_confirm = 2 will assure that the cluster has been in active state for at least 5 seconds, state_confirm = 3 assure at least 10 seconds, etc

    synced Boolean
    systemProjectId String
    (Computed) System project ID for the cluster sync (string)
    waitCatalogs Boolean
    Wait until all catalogs are downloaded and active. Default: false (bool)

    Supporting Types

    ClusterSyncNode, ClusterSyncNodeArgs

    Annotations Dictionary<string, string>
    Annotations of the resource
    Capacity Dictionary<string, string>
    The total resources of a node (map).
    ClusterId string
    The cluster ID that is syncing (string)
    ExternalIpAddress string
    The external IP address of the node (string).
    Hostname string
    The hostname of the node (string).
    Id string
    (Computed) The ID of the resource. Same as cluster_id (string)
    IpAddress string
    The private IP address of the node (string).
    Labels Dictionary<string, string>
    Labels of the resource
    Name string
    The name of the node (string).
    NodePoolId string
    The Node Pool ID of the node (string).
    NodeTemplateId string
    The Node Template ID of the node (string).
    ProviderId string
    The Provider ID of the node (string).
    RequestedHostname string
    The requested hostname (string).
    Roles List<string>
    Roles of the node. controlplane, etcd and worker. (list)
    SshUser string
    The user to connect to the node (string).
    SystemInfo Dictionary<string, string>
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
    Annotations map[string]string
    Annotations of the resource
    Capacity map[string]string
    The total resources of a node (map).
    ClusterId string
    The cluster ID that is syncing (string)
    ExternalIpAddress string
    The external IP address of the node (string).
    Hostname string
    The hostname of the node (string).
    Id string
    (Computed) The ID of the resource. Same as cluster_id (string)
    IpAddress string
    The private IP address of the node (string).
    Labels map[string]string
    Labels of the resource
    Name string
    The name of the node (string).
    NodePoolId string
    The Node Pool ID of the node (string).
    NodeTemplateId string
    The Node Template ID of the node (string).
    ProviderId string
    The Provider ID of the node (string).
    RequestedHostname string
    The requested hostname (string).
    Roles []string
    Roles of the node. controlplane, etcd and worker. (list)
    SshUser string
    The user to connect to the node (string).
    SystemInfo map[string]string
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
    annotations Map<String,String>
    Annotations of the resource
    capacity Map<String,String>
    The total resources of a node (map).
    clusterId String
    The cluster ID that is syncing (string)
    externalIpAddress String
    The external IP address of the node (string).
    hostname String
    The hostname of the node (string).
    id String
    (Computed) The ID of the resource. Same as cluster_id (string)
    ipAddress String
    The private IP address of the node (string).
    labels Map<String,String>
    Labels of the resource
    name String
    The name of the node (string).
    nodePoolId String
    The Node Pool ID of the node (string).
    nodeTemplateId String
    The Node Template ID of the node (string).
    providerId String
    The Provider ID of the node (string).
    requestedHostname String
    The requested hostname (string).
    roles List<String>
    Roles of the node. controlplane, etcd and worker. (list)
    sshUser String
    The user to connect to the node (string).
    systemInfo Map<String,String>
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
    annotations {[key: string]: string}
    Annotations of the resource
    capacity {[key: string]: string}
    The total resources of a node (map).
    clusterId string
    The cluster ID that is syncing (string)
    externalIpAddress string
    The external IP address of the node (string).
    hostname string
    The hostname of the node (string).
    id string
    (Computed) The ID of the resource. Same as cluster_id (string)
    ipAddress string
    The private IP address of the node (string).
    labels {[key: string]: string}
    Labels of the resource
    name string
    The name of the node (string).
    nodePoolId string
    The Node Pool ID of the node (string).
    nodeTemplateId string
    The Node Template ID of the node (string).
    providerId string
    The Provider ID of the node (string).
    requestedHostname string
    The requested hostname (string).
    roles string[]
    Roles of the node. controlplane, etcd and worker. (list)
    sshUser string
    The user to connect to the node (string).
    systemInfo {[key: string]: string}
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
    annotations Mapping[str, str]
    Annotations of the resource
    capacity Mapping[str, str]
    The total resources of a node (map).
    cluster_id str
    The cluster ID that is syncing (string)
    external_ip_address str
    The external IP address of the node (string).
    hostname str
    The hostname of the node (string).
    id str
    (Computed) The ID of the resource. Same as cluster_id (string)
    ip_address str
    The private IP address of the node (string).
    labels Mapping[str, str]
    Labels of the resource
    name str
    The name of the node (string).
    node_pool_id str
    The Node Pool ID of the node (string).
    node_template_id str
    The Node Template ID of the node (string).
    provider_id str
    The Provider ID of the node (string).
    requested_hostname str
    The requested hostname (string).
    roles Sequence[str]
    Roles of the node. controlplane, etcd and worker. (list)
    ssh_user str
    The user to connect to the node (string).
    system_info Mapping[str, str]
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.
    annotations Map<String>
    Annotations of the resource
    capacity Map<String>
    The total resources of a node (map).
    clusterId String
    The cluster ID that is syncing (string)
    externalIpAddress String
    The external IP address of the node (string).
    hostname String
    The hostname of the node (string).
    id String
    (Computed) The ID of the resource. Same as cluster_id (string)
    ipAddress String
    The private IP address of the node (string).
    labels Map<String>
    Labels of the resource
    name String
    The name of the node (string).
    nodePoolId String
    The Node Pool ID of the node (string).
    nodeTemplateId String
    The Node Template ID of the node (string).
    providerId String
    The Provider ID of the node (string).
    requestedHostname String
    The requested hostname (string).
    roles List<String>
    Roles of the node. controlplane, etcd and worker. (list)
    sshUser String
    The user to connect to the node (string).
    systemInfo Map<String>
    General information about the node, such as kernel version, kubelet and kube-proxy version, Docker version (if used), and OS name.

    Package Details

    Repository
    Rancher2 pulumi/pulumi-rancher2
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the rancher2 Terraform Provider.
    rancher2 logo
    Rancher 2 v8.0.0 published on Wednesday, Dec 4, 2024 by Pulumi