rancher2.NodeTemplate

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

// Create a new rancher2 Node Template up to Rancher 2.1.x
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>",
    },
});

import pulumi
import pulumi_rancher2 as rancher2

# Create a new rancher2 Node Template up to Rancher 2.1.x
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>",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new rancher2 Node Template up to Rancher 2.1.x
		_, 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
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create a new rancher2 Node Template up to Rancher 2.1.x
    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>",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rancher2.NodeTemplate;
import com.pulumi.rancher2.NodeTemplateArgs;
import com.pulumi.rancher2.inputs.NodeTemplateAmazonec2ConfigArgs;
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 Node Template up to Rancher 2.1.x
        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());

    }
}

resources:
  # Create a new rancher2 Node Template up to Rancher 2.1.x
  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>

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

// Create a new rancher2 Node Template from Rancher 2.2.x
const foo = new rancher2.CloudCredential("foo", {
    name: "foo",
    description: "foo test",
    amazonec2CredentialConfig: {
        accessKey: "<AWS_ACCESS_KEY>",
        secretKey: "<AWS_SECRET_KEY>",
    },
});
const fooNodeTemplate = new rancher2.NodeTemplate("foo", {
    name: "foo",
    description: "foo test",
    cloudCredentialId: foo.id,
    amazonec2Config: {
        ami: "<AMI_ID>",
        region: "<REGION>",
        securityGroups: ["<AWS_SECURITY_GROUP>"],
        subnetId: "<SUBNET_ID>",
        vpcId: "<VPC_ID>",
        zone: "<ZONE>",
    },
});

import pulumi
import pulumi_rancher2 as rancher2

# Create a new rancher2 Node Template from Rancher 2.2.x
foo = rancher2.CloudCredential("foo",
    name="foo",
    description="foo test",
    amazonec2_credential_config={
        "access_key": "<AWS_ACCESS_KEY>",
        "secret_key": "<AWS_SECRET_KEY>",
    })
foo_node_template = rancher2.NodeTemplate("foo",
    name="foo",
    description="foo test",
    cloud_credential_id=foo.id,
    amazonec2_config={
        "ami": "<AMI_ID>",
        "region": "<REGION>",
        "security_groups": ["<AWS_SECURITY_GROUP>"],
        "subnet_id": "<SUBNET_ID>",
        "vpc_id": "<VPC_ID>",
        "zone": "<ZONE>",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new rancher2 Node Template from Rancher 2.2.x
		foo, err := rancher2.NewCloudCredential(ctx, "foo", &rancher2.CloudCredentialArgs{
			Name:        pulumi.String("foo"),
			Description: pulumi.String("foo test"),
			Amazonec2CredentialConfig: &rancher2.CloudCredentialAmazonec2CredentialConfigArgs{
				AccessKey: pulumi.String("<AWS_ACCESS_KEY>"),
				SecretKey: pulumi.String("<AWS_SECRET_KEY>"),
			},
		})
		if err != nil {
			return err
		}
		_, err = rancher2.NewNodeTemplate(ctx, "foo", &rancher2.NodeTemplateArgs{
			Name:              pulumi.String("foo"),
			Description:       pulumi.String("foo test"),
			CloudCredentialId: foo.ID(),
			Amazonec2Config: &rancher2.NodeTemplateAmazonec2ConfigArgs{
				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
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Create a new rancher2 Node Template from Rancher 2.2.x
    var foo = new Rancher2.CloudCredential("foo", new()
    {
        Name = "foo",
        Description = "foo test",
        Amazonec2CredentialConfig = new Rancher2.Inputs.CloudCredentialAmazonec2CredentialConfigArgs
        {
            AccessKey = "<AWS_ACCESS_KEY>",
            SecretKey = "<AWS_SECRET_KEY>",
        },
    });

    var fooNodeTemplate = new Rancher2.NodeTemplate("foo", new()
    {
        Name = "foo",
        Description = "foo test",
        CloudCredentialId = foo.Id,
        Amazonec2Config = new Rancher2.Inputs.NodeTemplateAmazonec2ConfigArgs
        {
            Ami = "<AMI_ID>",
            Region = "<REGION>",
            SecurityGroups = new[]
            {
                "<AWS_SECURITY_GROUP>",
            },
            SubnetId = "<SUBNET_ID>",
            VpcId = "<VPC_ID>",
            Zone = "<ZONE>",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rancher2.CloudCredential;
import com.pulumi.rancher2.CloudCredentialArgs;
import com.pulumi.rancher2.inputs.CloudCredentialAmazonec2CredentialConfigArgs;
import com.pulumi.rancher2.NodeTemplate;
import com.pulumi.rancher2.NodeTemplateArgs;
import com.pulumi.rancher2.inputs.NodeTemplateAmazonec2ConfigArgs;
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 Node Template from Rancher 2.2.x
        var foo = new CloudCredential("foo", CloudCredentialArgs.builder()
            .name("foo")
            .description("foo test")
            .amazonec2CredentialConfig(CloudCredentialAmazonec2CredentialConfigArgs.builder()
                .accessKey("<AWS_ACCESS_KEY>")
                .secretKey("<AWS_SECRET_KEY>")
                .build())
            .build());

        var fooNodeTemplate = new NodeTemplate("fooNodeTemplate", NodeTemplateArgs.builder()
            .name("foo")
            .description("foo test")
            .cloudCredentialId(foo.id())
            .amazonec2Config(NodeTemplateAmazonec2ConfigArgs.builder()
                .ami("<AMI_ID>")
                .region("<REGION>")
                .securityGroups("<AWS_SECURITY_GROUP>")
                .subnetId("<SUBNET_ID>")
                .vpcId("<VPC_ID>")
                .zone("<ZONE>")
                .build())
            .build());

    }
}

resources:
  # Create a new rancher2 Node Template from Rancher 2.2.x
  foo:
    type: rancher2:CloudCredential
    properties:
      name: foo
      description: foo test
      amazonec2CredentialConfig:
        accessKey: <AWS_ACCESS_KEY>
        secretKey: <AWS_SECRET_KEY>
  fooNodeTemplate:
    type: rancher2:NodeTemplate
    name: foo
    properties:
      name: foo
      description: foo test
      cloudCredentialId: ${foo.id}
      amazonec2Config:
        ami: <AMI_ID>
        region: <REGION>
        securityGroups:
          - <AWS_SECURITY_GROUP>
        subnetId: <SUBNET_ID>
        vpcId: <VPC_ID>
        zone: <ZONE>

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

// Get imported harvester cluster info
const foo-harvester = rancher2.getClusterV2({
    name: "foo-harvester",
});
// Create a new Cloud Credential for an imported Harvester cluster
const foo_harvesterCloudCredential = new rancher2.CloudCredential("foo-harvester", {
    name: "foo-harvester",
    harvesterCredentialConfig: {
        clusterId: foo_harvester.then(foo_harvester => foo_harvester.clusterV1Id),
        clusterType: "imported",
        kubeconfigContent: foo_harvester.then(foo_harvester => foo_harvester.kubeConfig),
    },
});
// Create a new rancher2 Node Template using harvester node_driver
const foo_harvesterNodeTemplate = new rancher2.NodeTemplate("foo-harvester", {
    name: "foo-harvester",
    cloudCredentialId: foo_harvesterCloudCredential.id,
    engineInstallUrl: "https://releases.rancher.com/install-docker/20.10.sh",
    harvesterConfig: {
        vmNamespace: "default",
        cpuCount: "2",
        memorySize: "4",
        diskInfo: `    {
        "disks": [{
            "imageName": "harvester-public/image-57hzg",
            "size": 40,
            "bootOrder": 1
        }]
    }
`,
        networkInfo: `    {
        "interfaces": [{
            "networkName": "harvester-public/vlan1"
        }]
    }
`,
        sshUser: "ubuntu",
        userData: `    package_update: true
    packages:
      - qemu-guest-agent
      - iptables
    runcmd:
      - - systemctl
        - enable
        - '--now'
        - qemu-guest-agent.service
`,
    },
});

import pulumi
import pulumi_rancher2 as rancher2

# Get imported harvester cluster info
foo_harvester = rancher2.get_cluster_v2(name="foo-harvester")
# Create a new Cloud Credential for an imported Harvester cluster
foo_harvester_cloud_credential = rancher2.CloudCredential("foo-harvester",
    name="foo-harvester",
    harvester_credential_config={
        "cluster_id": foo_harvester.cluster_v1_id,
        "cluster_type": "imported",
        "kubeconfig_content": foo_harvester.kube_config,
    })
# Create a new rancher2 Node Template using harvester node_driver
foo_harvester_node_template = rancher2.NodeTemplate("foo-harvester",
    name="foo-harvester",
    cloud_credential_id=foo_harvester_cloud_credential.id,
    engine_install_url="https://releases.rancher.com/install-docker/20.10.sh",
    harvester_config={
        "vm_namespace": "default",
        "cpu_count": "2",
        "memory_size": "4",
        "disk_info": """    {
        "disks": [{
            "imageName": "harvester-public/image-57hzg",
            "size": 40,
            "bootOrder": 1
        }]
    }
""",
        "network_info": """    {
        "interfaces": [{
            "networkName": "harvester-public/vlan1"
        }]
    }
""",
        "ssh_user": "ubuntu",
        "user_data": """    package_update: true
    packages:
      - qemu-guest-agent
      - iptables
    runcmd:
      - - systemctl
        - enable
        - '--now'
        - qemu-guest-agent.service
""",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get imported harvester cluster info
		foo_harvester, err := rancher2.LookupClusterV2(ctx, &rancher2.LookupClusterV2Args{
			Name: "foo-harvester",
		}, nil)
		if err != nil {
			return err
		}
		// Create a new Cloud Credential for an imported Harvester cluster
		_, err = rancher2.NewCloudCredential(ctx, "foo-harvester", &rancher2.CloudCredentialArgs{
			Name: pulumi.String("foo-harvester"),
			HarvesterCredentialConfig: &rancher2.CloudCredentialHarvesterCredentialConfigArgs{
				ClusterId:         pulumi.String(foo_harvester.ClusterV1Id),
				ClusterType:       pulumi.String("imported"),
				KubeconfigContent: pulumi.String(foo_harvester.KubeConfig),
			},
		})
		if err != nil {
			return err
		}
		// Create a new rancher2 Node Template using harvester node_driver
		_, err = rancher2.NewNodeTemplate(ctx, "foo-harvester", &rancher2.NodeTemplateArgs{
			Name:              pulumi.String("foo-harvester"),
			CloudCredentialId: foo_harvesterCloudCredential.ID(),
			EngineInstallUrl:  pulumi.String("https://releases.rancher.com/install-docker/20.10.sh"),
			HarvesterConfig: &rancher2.NodeTemplateHarvesterConfigArgs{
				VmNamespace: pulumi.String("default"),
				CpuCount:    pulumi.String("2"),
				MemorySize:  pulumi.String("4"),
				DiskInfo: pulumi.String(`    {
        "disks": [{
            "imageName": "harvester-public/image-57hzg",
            "size": 40,
            "bootOrder": 1
        }]
    }
`),
				NetworkInfo: pulumi.String(`    {
        "interfaces": [{
            "networkName": "harvester-public/vlan1"
        }]
    }
`),
				SshUser: pulumi.String("ubuntu"),
				UserData: pulumi.String(`    package_update: true
    packages:
      - qemu-guest-agent
      - iptables
    runcmd:
      - - systemctl
        - enable
        - '--now'
        - qemu-guest-agent.service
`),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Get imported harvester cluster info
    var foo_harvester = Rancher2.GetClusterV2.Invoke(new()
    {
        Name = "foo-harvester",
    });

    // Create a new Cloud Credential for an imported Harvester cluster
    var foo_harvesterCloudCredential = new Rancher2.CloudCredential("foo-harvester", new()
    {
        Name = "foo-harvester",
        HarvesterCredentialConfig = new Rancher2.Inputs.CloudCredentialHarvesterCredentialConfigArgs
        {
            ClusterId = foo_harvester.Apply(foo_harvester => foo_harvester.Apply(getClusterV2Result => getClusterV2Result.ClusterV1Id)),
            ClusterType = "imported",
            KubeconfigContent = foo_harvester.Apply(foo_harvester => foo_harvester.Apply(getClusterV2Result => getClusterV2Result.KubeConfig)),
        },
    });

    // Create a new rancher2 Node Template using harvester node_driver
    var foo_harvesterNodeTemplate = new Rancher2.NodeTemplate("foo-harvester", new()
    {
        Name = "foo-harvester",
        CloudCredentialId = foo_harvesterCloudCredential.Id,
        EngineInstallUrl = "https://releases.rancher.com/install-docker/20.10.sh",
        HarvesterConfig = new Rancher2.Inputs.NodeTemplateHarvesterConfigArgs
        {
            VmNamespace = "default",
            CpuCount = "2",
            MemorySize = "4",
            DiskInfo = @"    {
        ""disks"": [{
            ""imageName"": ""harvester-public/image-57hzg"",
            ""size"": 40,
            ""bootOrder"": 1
        }]
    }
",
            NetworkInfo = @"    {
        ""interfaces"": [{
            ""networkName"": ""harvester-public/vlan1""
        }]
    }
",
            SshUser = "ubuntu",
            UserData = @"    package_update: true
    packages:
      - qemu-guest-agent
      - iptables
    runcmd:
      - - systemctl
        - enable
        - '--now'
        - qemu-guest-agent.service
",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rancher2.Rancher2Functions;
import com.pulumi.rancher2.inputs.GetClusterV2Args;
import com.pulumi.rancher2.CloudCredential;
import com.pulumi.rancher2.CloudCredentialArgs;
import com.pulumi.rancher2.inputs.CloudCredentialHarvesterCredentialConfigArgs;
import com.pulumi.rancher2.NodeTemplate;
import com.pulumi.rancher2.NodeTemplateArgs;
import com.pulumi.rancher2.inputs.NodeTemplateHarvesterConfigArgs;
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) {
        // Get imported harvester cluster info
        final var foo-harvester = Rancher2Functions.getClusterV2(GetClusterV2Args.builder()
            .name("foo-harvester")
            .build());

        // Create a new Cloud Credential for an imported Harvester cluster
        var foo_harvesterCloudCredential = new CloudCredential("foo-harvesterCloudCredential", CloudCredentialArgs.builder()
            .name("foo-harvester")
            .harvesterCredentialConfig(CloudCredentialHarvesterCredentialConfigArgs.builder()
                .clusterId(foo_harvester.clusterV1Id())
                .clusterType("imported")
                .kubeconfigContent(foo_harvester.kubeConfig())
                .build())
            .build());

        // Create a new rancher2 Node Template using harvester node_driver
        var foo_harvesterNodeTemplate = new NodeTemplate("foo-harvesterNodeTemplate", NodeTemplateArgs.builder()
            .name("foo-harvester")
            .cloudCredentialId(foo_harvesterCloudCredential.id())
            .engineInstallUrl("https://releases.rancher.com/install-docker/20.10.sh")
            .harvesterConfig(NodeTemplateHarvesterConfigArgs.builder()
                .vmNamespace("default")
                .cpuCount("2")
                .memorySize("4")
                .diskInfo("""
    {
        "disks": [{
            "imageName": "harvester-public/image-57hzg",
            "size": 40,
            "bootOrder": 1
        }]
    }
                """)
                .networkInfo("""
    {
        "interfaces": [{
            "networkName": "harvester-public/vlan1"
        }]
    }
                """)
                .sshUser("ubuntu")
                .userData("""
    package_update: true
    packages:
      - qemu-guest-agent
      - iptables
    runcmd:
      - - systemctl
        - enable
        - '--now'
        - qemu-guest-agent.service
                """)
                .build())
            .build());

    }
}

resources:
  # Create a new Cloud Credential for an imported Harvester cluster
  foo-harvesterCloudCredential:
    type: rancher2:CloudCredential
    name: foo-harvester
    properties:
      name: foo-harvester
      harvesterCredentialConfig:
        clusterId: ${["foo-harvester"].clusterV1Id}
        clusterType: imported
        kubeconfigContent: ${["foo-harvester"].kubeConfig}
  # Create a new rancher2 Node Template using harvester node_driver
  foo-harvesterNodeTemplate:
    type: rancher2:NodeTemplate
    name: foo-harvester
    properties:
      name: foo-harvester
      cloudCredentialId: ${["foo-harvesterCloudCredential"].id}
      engineInstallUrl: https://releases.rancher.com/install-docker/20.10.sh
      harvesterConfig:
        vmNamespace: default
        cpuCount: '2'
        memorySize: '4'
        diskInfo: |2
              {
                  "disks": [{
                      "imageName": "harvester-public/image-57hzg",
                      "size": 40,
                      "bootOrder": 1
                  }]
              }
        networkInfo: |2
              {
                  "interfaces": [{
                      "networkName": "harvester-public/vlan1"
                  }]
              }
        sshUser: ubuntu
        userData: |2
              package_update: true
              packages:
                - qemu-guest-agent
                - iptables
              runcmd:
                - - systemctl
                  - enable
                  - '--now'
                  - qemu-guest-agent.service
variables:
  # Get imported harvester cluster info
  foo-harvester:
    fn::invoke:
      Function: rancher2:getClusterV2
      Arguments:
        name: foo-harvester

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

// Create a new rancher2 Node Template using hetzner node_driver
const hetznerNodeDriver = new rancher2.NodeDriver("hetzner_node_driver", {
    active: true,
    builtin: false,
    name: "Hetzner",
    uiUrl: "https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js",
    url: "https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz",
    whitelistDomains: ["storage.googleapis.com"],
});
const myHetznerNodeTemplate = new rancher2.NodeTemplate("my_hetzner_node_template", {
    name: "my-hetzner-node-template",
    driverId: hetznerNodeDriver.id,
    hetznerConfig: {
        apiToken: "XXXXXXXXXX",
        image: "ubuntu-18.04",
        serverLocation: "nbg1",
        serverType: "cx11",
    },
});

import pulumi
import pulumi_rancher2 as rancher2

# Create a new rancher2 Node Template using hetzner node_driver
hetzner_node_driver = rancher2.NodeDriver("hetzner_node_driver",
    active=True,
    builtin=False,
    name="Hetzner",
    ui_url="https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js",
    url="https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz",
    whitelist_domains=["storage.googleapis.com"])
my_hetzner_node_template = rancher2.NodeTemplate("my_hetzner_node_template",
    name="my-hetzner-node-template",
    driver_id=hetzner_node_driver.id,
    hetzner_config={
        "api_token": "XXXXXXXXXX",
        "image": "ubuntu-18.04",
        "server_location": "nbg1",
        "server_type": "cx11",
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new rancher2 Node Template using hetzner node_driver
		hetznerNodeDriver, err := rancher2.NewNodeDriver(ctx, "hetzner_node_driver", &rancher2.NodeDriverArgs{
			Active:  pulumi.Bool(true),
			Builtin: pulumi.Bool(false),
			Name:    pulumi.String("Hetzner"),
			UiUrl:   pulumi.String("https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js"),
			Url:     pulumi.String("https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz"),
			WhitelistDomains: pulumi.StringArray{
				pulumi.String("storage.googleapis.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = rancher2.NewNodeTemplate(ctx, "my_hetzner_node_template", &rancher2.NodeTemplateArgs{
			Name:     pulumi.String("my-hetzner-node-template"),
			DriverId: hetznerNodeDriver.ID(),
			HetznerConfig: &rancher2.NodeTemplateHetznerConfigArgs{
				ApiToken:       pulumi.String("XXXXXXXXXX"),
				Image:          pulumi.String("ubuntu-18.04"),
				ServerLocation: pulumi.String("nbg1"),
				ServerType:     pulumi.String("cx11"),
			},
		})
		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 Node Template using hetzner node_driver
    var hetznerNodeDriver = new Rancher2.NodeDriver("hetzner_node_driver", new()
    {
        Active = true,
        Builtin = false,
        Name = "Hetzner",
        UiUrl = "https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js",
        Url = "https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz",
        WhitelistDomains = new[]
        {
            "storage.googleapis.com",
        },
    });

    var myHetznerNodeTemplate = new Rancher2.NodeTemplate("my_hetzner_node_template", new()
    {
        Name = "my-hetzner-node-template",
        DriverId = hetznerNodeDriver.Id,
        HetznerConfig = new Rancher2.Inputs.NodeTemplateHetznerConfigArgs
        {
            ApiToken = "XXXXXXXXXX",
            Image = "ubuntu-18.04",
            ServerLocation = "nbg1",
            ServerType = "cx11",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rancher2.NodeDriver;
import com.pulumi.rancher2.NodeDriverArgs;
import com.pulumi.rancher2.NodeTemplate;
import com.pulumi.rancher2.NodeTemplateArgs;
import com.pulumi.rancher2.inputs.NodeTemplateHetznerConfigArgs;
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 Node Template using hetzner node_driver
        var hetznerNodeDriver = new NodeDriver("hetznerNodeDriver", NodeDriverArgs.builder()
            .active(true)
            .builtin(false)
            .name("Hetzner")
            .uiUrl("https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js")
            .url("https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz")
            .whitelistDomains("storage.googleapis.com")
            .build());

        var myHetznerNodeTemplate = new NodeTemplate("myHetznerNodeTemplate", NodeTemplateArgs.builder()
            .name("my-hetzner-node-template")
            .driverId(hetznerNodeDriver.id())
            .hetznerConfig(NodeTemplateHetznerConfigArgs.builder()
                .apiToken("XXXXXXXXXX")
                .image("ubuntu-18.04")
                .serverLocation("nbg1")
                .serverType("cx11")
                .build())
            .build());

    }
}

resources:
  # Create a new rancher2 Node Template using hetzner node_driver
  hetznerNodeDriver:
    type: rancher2:NodeDriver
    name: hetzner_node_driver
    properties:
      active: true
      builtin: false
      name: Hetzner
      uiUrl: https://storage.googleapis.com/hcloud-rancher-v2-ui-driver/component.js
      url: https://github.com/JonasProgrammer/docker-machine-driver-hetzner/releases/download/3.6.0/docker-machine-driver-hetzner_3.6.0_linux_amd64.tar.gz
      whitelistDomains:
        - storage.googleapis.com
  myHetznerNodeTemplate:
    type: rancher2:NodeTemplate
    name: my_hetzner_node_template
    properties:
      name: my-hetzner-node-template
      driverId: ${hetznerNodeDriver.id}
      hetznerConfig:
        apiToken: XXXXXXXXXX
        image: ubuntu-18.04
        serverLocation: nbg1
        serverType: cx11

var nodeTemplateResource = new Rancher2.NodeTemplate("nodeTemplateResource", new()
{
    Amazonec2Config = new Rancher2.Inputs.NodeTemplateAmazonec2ConfigArgs
    {
        Region = "string",
        Ami = "string",
        Zone = "string",
        VpcId = "string",
        SubnetId = "string",
        SecurityGroups = new[]
        {
            "string",
        },
        RequestSpotInstance = false,
        SecretKey = "string",
        IamInstanceProfile = "string",
        InsecureTransport = false,
        InstanceType = "string",
        KmsKey = "string",
        Monitoring = false,
        OpenPorts = new[]
        {
            "string",
        },
        PrivateAddressOnly = false,
        HttpEndpoint = "string",
        AccessKey = "string",
        Retries = "string",
        RootSize = "string",
        HttpTokens = "string",
        SecurityGroupReadonly = false,
        Endpoint = "string",
        SessionToken = "string",
        SpotPrice = "string",
        SshKeypath = "string",
        SshUser = "string",
        EncryptEbsVolume = false,
        Tags = "string",
        UseEbsOptimizedInstance = false,
        UsePrivateAddress = false,
        Userdata = "string",
        VolumeType = "string",
        DeviceName = "string",
        BlockDurationMinutes = "string",
    },
    Annotations = 
    {
        { "string", "string" },
    },
    AuthCertificateAuthority = "string",
    AuthKey = "string",
    AzureConfig = new Rancher2.Inputs.NodeTemplateAzureConfigArgs
    {
        AcceleratedNetworking = false,
        AvailabilitySet = "string",
        AvailabilityZone = "string",
        ClientId = "string",
        ClientSecret = "string",
        CustomData = "string",
        DiskSize = "string",
        Dns = "string",
        DockerPort = "string",
        Environment = "string",
        FaultDomainCount = "string",
        Image = "string",
        Location = "string",
        ManagedDisks = false,
        NoPublicIp = false,
        Nsg = "string",
        OpenPorts = new[]
        {
            "string",
        },
        Plan = "string",
        PrivateIpAddress = "string",
        ResourceGroup = "string",
        Size = "string",
        SshUser = "string",
        StaticPublicIp = false,
        StorageType = "string",
        Subnet = "string",
        SubnetPrefix = "string",
        SubscriptionId = "string",
        Tags = "string",
        UpdateDomainCount = "string",
        UsePrivateIp = false,
        UsePublicIpStandardSku = false,
        Vnet = "string",
    },
    CloudCredentialId = "string",
    Description = "string",
    DigitaloceanConfig = new Rancher2.Inputs.NodeTemplateDigitaloceanConfigArgs
    {
        AccessToken = "string",
        Backups = false,
        Image = "string",
        Ipv6 = false,
        Monitoring = false,
        PrivateNetworking = false,
        Region = "string",
        Size = "string",
        SshKeyFingerprint = "string",
        SshKeyPath = "string",
        SshPort = "string",
        SshUser = "string",
        Tags = "string",
        Userdata = "string",
    },
    DriverId = "string",
    EngineEnv = 
    {
        { "string", "string" },
    },
    EngineInsecureRegistries = new[]
    {
        "string",
    },
    EngineInstallUrl = "string",
    EngineLabel = 
    {
        { "string", "string" },
    },
    EngineOpt = 
    {
        { "string", "string" },
    },
    EngineRegistryMirrors = new[]
    {
        "string",
    },
    EngineStorageDriver = "string",
    HarvesterConfig = new Rancher2.Inputs.NodeTemplateHarvesterConfigArgs
    {
        SshUser = "string",
        VmNamespace = "string",
        NetworkData = "string",
        MemorySize = "string",
        CpuCount = "string",
        NetworkInfo = "string",
        SshPassword = "string",
        DiskInfo = "string",
        UserData = "string",
        VmAffinity = "string",
    },
    HetznerConfig = new Rancher2.Inputs.NodeTemplateHetznerConfigArgs
    {
        ApiToken = "string",
        Image = "string",
        Networks = "string",
        ServerLabels = 
        {
            { "string", "string" },
        },
        ServerLocation = "string",
        ServerType = "string",
        UsePrivateNetwork = false,
        Userdata = "string",
        Volumes = "string",
    },
    Labels = 
    {
        { "string", "string" },
    },
    LinodeConfig = new Rancher2.Inputs.NodeTemplateLinodeConfigArgs
    {
        AuthorizedUsers = "string",
        CreatePrivateIp = false,
        DockerPort = "string",
        Image = "string",
        InstanceType = "string",
        Label = "string",
        Region = "string",
        RootPass = "string",
        SshPort = "string",
        SshUser = "string",
        Stackscript = "string",
        StackscriptData = "string",
        SwapSize = "string",
        Tags = "string",
        Token = "string",
        UaPrefix = "string",
    },
    Name = "string",
    NodeTaints = new[]
    {
        new Rancher2.Inputs.NodeTemplateNodeTaintArgs
        {
            Key = "string",
            Value = "string",
            Effect = "string",
            TimeAdded = "string",
        },
    },
    OpennebulaConfig = new Rancher2.Inputs.NodeTemplateOpennebulaConfigArgs
    {
        Password = "string",
        XmlRpcUrl = "string",
        User = "string",
        DiskResize = "string",
        NetworkName = "string",
        ImageId = "string",
        ImageName = "string",
        ImageOwner = "string",
        Memory = "string",
        NetworkId = "string",
        B2dSize = "string",
        NetworkOwner = "string",
        DisableVnc = false,
        SshUser = "string",
        TemplateId = "string",
        TemplateName = "string",
        DevPrefix = "string",
        Vcpu = "string",
        Cpu = "string",
    },
    OpenstackConfig = new Rancher2.Inputs.NodeTemplateOpenstackConfigArgs
    {
        AuthUrl = "string",
        Region = "string",
        AvailabilityZone = "string",
        IpVersion = "string",
        BootFromVolume = false,
        ApplicationCredentialName = "string",
        NetId = "string",
        Cacert = "string",
        NetName = "string",
        DomainId = "string",
        DomainName = "string",
        EndpointType = "string",
        FlavorId = "string",
        FlavorName = "string",
        FloatingIpPool = "string",
        ImageId = "string",
        ImageName = "string",
        Insecure = false,
        ActiveTimeout = "string",
        VolumeSize = "string",
        ApplicationCredentialSecret = "string",
        ConfigDrive = false,
        NovaNetwork = false,
        Password = "string",
        PrivateKeyFile = "string",
        ApplicationCredentialId = "string",
        SecGroups = "string",
        SshPort = "string",
        SshUser = "string",
        TenantId = "string",
        TenantName = "string",
        UserDataFile = "string",
        Username = "string",
        VolumeDevicePath = "string",
        VolumeId = "string",
        VolumeName = "string",
        KeypairName = "string",
        VolumeType = "string",
    },
    OutscaleConfig = new Rancher2.Inputs.NodeTemplateOutscaleConfigArgs
    {
        AccessKey = "string",
        SecretKey = "string",
        ExtraTagsAlls = new[]
        {
            "string",
        },
        ExtraTagsInstances = new[]
        {
            "string",
        },
        InstanceType = "string",
        Region = "string",
        RootDiskIops = 0,
        RootDiskSize = 0,
        RootDiskType = "string",
        SecurityGroupIds = new[]
        {
            "string",
        },
        SourceOmi = "string",
    },
    UseInternalIpAddress = false,
    VsphereConfig = new Rancher2.Inputs.NodeTemplateVsphereConfigArgs
    {
        Boot2dockerUrl = "string",
        Cfgparams = new[]
        {
            "string",
        },
        CloneFrom = "string",
        CloudConfig = "string",
        Cloudinit = "string",
        ContentLibrary = "string",
        CpuCount = "string",
        CreationType = "string",
        CustomAttributes = new[]
        {
            "string",
        },
        Datacenter = "string",
        Datastore = "string",
        DatastoreCluster = "string",
        DiskSize = "string",
        Folder = "string",
        GracefulShutdownTimeout = "string",
        Hostsystem = "string",
        MemorySize = "string",
        Networks = new[]
        {
            "string",
        },
        Password = "string",
        Pool = "string",
        SshPassword = "string",
        SshPort = "string",
        SshUser = "string",
        SshUserGroup = "string",
        Tags = new[]
        {
            "string",
        },
        Username = "string",
        VappIpAllocationPolicy = "string",
        VappIpProtocol = "string",
        VappProperties = new[]
        {
            "string",
        },
        VappTransport = "string",
        Vcenter = "string",
        VcenterPort = "string",
    },
});