1. Packages
  2. Gcorelabs Provider
gcorelabs 0.3.63 published on Monday, Apr 14, 2025 by g-core

Gcorelabs Provider

gcorelabs logo
gcorelabs 0.3.63 published on Monday, Apr 14, 2025 by g-core

    Generate Provider

    The Gcorelabs provider must be installed as a Local Package by following the instructions for Any Terraform Provider:

    pulumi package add terraform-provider g-core/gcorelabs
    

    Example Usage

    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: nodejs
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    import * as pulumi from "@pulumi/pulumi";
    import * as gcorelabs from "@pulumi/gcorelabs";
    
    const kp = new gcorelabs.Keypair("kp", {
        projectId: 1,
        publicKey: "your oub key",
        sshkeyName: "testkey",
    });
    const network = new gcorelabs.Network("network", {
        name: "network_example",
        mtu: 1450,
        type: "vxlan",
        regionId: 1,
        projectId: 1,
    });
    const subnet = new gcorelabs.Subnet("subnet", {
        name: "subnet_example",
        cidr: "192.168.10.0/24",
        networkId: network.networkId,
        dnsNameservers: [
            "8.8.4.4",
            "1.1.1.1",
        ],
        hostRoutes: [{
            destination: "10.0.3.0/24",
            nexthop: "10.0.0.13",
        }],
        gatewayIp: "192.168.10.1",
        regionId: 1,
        projectId: 1,
    });
    const subnet2 = new gcorelabs.Subnet("subnet2", {
        name: "subnet2_example",
        cidr: "192.168.20.0/24",
        networkId: network.networkId,
        dnsNameservers: [
            "8.8.4.4",
            "1.1.1.1",
        ],
        hostRoutes: [{
            destination: "10.0.3.0/24",
            nexthop: "10.0.0.13",
        }],
        gatewayIp: "192.168.20.1",
        regionId: 1,
        projectId: 1,
    });
    const firstVolume = new gcorelabs.Volume("first_volume", {
        name: "boot volume",
        typeName: "ssd_hiiops",
        size: 6,
        imageId: "f4ce3d30-e29c-4cfd-811f-46f383b6081f",
        regionId: 1,
        projectId: 1,
    });
    const secondVolume = new gcorelabs.Volume("second_volume", {
        name: "second volume",
        typeName: "ssd_hiiops",
        imageId: "f4ce3d30-e29c-4cfd-811f-46f383b6081f",
        size: 6,
        regionId: 1,
        projectId: 1,
    });
    const thirdVolume = new gcorelabs.Volume("third_volume", {
        name: "third volume",
        typeName: "ssd_hiiops",
        size: 6,
        regionId: 1,
        projectId: 1,
    });
    const instance = new gcorelabs.Instance("instance", {
        flavorId: "g1-standard-2-4",
        name: "test",
        keypairName: kp.sshkeyName,
        volumes: [{
            source: "existing-volume",
            volumeId: firstVolume.volumeId,
            bootIndex: 0,
        }],
        interfaces: [
            {
                type: "subnet",
                networkId: network.networkId,
                subnetId: subnet.subnetId,
            },
            {
                type: "subnet",
                networkId: network.networkId,
                subnetId: subnet2.subnetId,
            },
        ],
        securityGroups: [{
            id: "66988147-f1b9-43b2-aaef-dee6d009b5b7",
            name: "default",
        }],
        metadatas: [{
            key: "some_key",
            value: "some_data",
        }],
        configurations: [{
            key: "some_key",
            value: "some_data",
        }],
        regionId: 1,
        projectId: 1,
    });
    const lb = new gcorelabs.Loadbalancer("lb", {
        projectId: 1,
        regionId: 1,
        name: "test1",
        flavor: "lb1-1-2",
        listener: {
            name: "test",
            protocol: "HTTP",
            protocolPort: 80,
        },
    });
    const pl = new gcorelabs.Lbpool("pl", {
        projectId: 1,
        regionId: 1,
        name: "test_pool1",
        protocol: "HTTP",
        lbAlgorithm: "LEAST_CONNECTIONS",
        loadbalancerId: lb.loadbalancerId,
        listenerId: lb.listener.apply(listener => listener.id),
        healthMonitor: {
            type: "PING",
            delay: 60,
            maxRetries: 5,
            timeout: 10,
        },
        sessionPersistence: {
            type: "APP_COOKIE",
            cookieName: "test_new_cookie",
        },
    });
    const lbm = new gcorelabs.Lbmember("lbm", {
        projectId: 1,
        regionId: 1,
        poolId: pl.lbpoolId,
        instanceId: instance.instanceId,
        address: instance.interfaces.apply(interfaces => interfaces[0].ipAddress),
        protocolPort: 8081,
        weight: 5,
    });
    const instance2 = new gcorelabs.Instance("instance2", {
        flavorId: "g1-standard-2-4",
        name: "test2",
        keypairName: kp.sshkeyName,
        volumes: [
            {
                source: "existing-volume",
                volumeId: secondVolume.volumeId,
                bootIndex: 0,
            },
            {
                source: "existing-volume",
                volumeId: thirdVolume.volumeId,
                bootIndex: 1,
            },
        ],
        interfaces: [{
            type: "subnet",
            networkId: network.networkId,
            subnetId: subnet.subnetId,
        }],
        securityGroups: [{
            id: "66988147-f1b9-43b2-aaef-dee6d009b5b7",
            name: "default",
        }],
        metadatas: [{
            key: "some_key",
            value: "some_data",
        }],
        configurations: [{
            key: "some_key",
            value: "some_data",
        }],
        regionId: 1,
        projectId: 1,
    });
    const lbm2 = new gcorelabs.Lbmember("lbm2", {
        projectId: 1,
        regionId: 1,
        poolId: pl.lbpoolId,
        instanceId: instance2.instanceId,
        address: instance2.interfaces.apply(interfaces => interfaces[0].ipAddress),
        protocolPort: 8081,
        weight: 5,
    });
    
    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: python
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    import pulumi
    import pulumi_gcorelabs as gcorelabs
    
    kp = gcorelabs.Keypair("kp",
        project_id=1,
        public_key="your oub key",
        sshkey_name="testkey")
    network = gcorelabs.Network("network",
        name="network_example",
        mtu=1450,
        type="vxlan",
        region_id=1,
        project_id=1)
    subnet = gcorelabs.Subnet("subnet",
        name="subnet_example",
        cidr="192.168.10.0/24",
        network_id=network.network_id,
        dns_nameservers=[
            "8.8.4.4",
            "1.1.1.1",
        ],
        host_routes=[{
            "destination": "10.0.3.0/24",
            "nexthop": "10.0.0.13",
        }],
        gateway_ip="192.168.10.1",
        region_id=1,
        project_id=1)
    subnet2 = gcorelabs.Subnet("subnet2",
        name="subnet2_example",
        cidr="192.168.20.0/24",
        network_id=network.network_id,
        dns_nameservers=[
            "8.8.4.4",
            "1.1.1.1",
        ],
        host_routes=[{
            "destination": "10.0.3.0/24",
            "nexthop": "10.0.0.13",
        }],
        gateway_ip="192.168.20.1",
        region_id=1,
        project_id=1)
    first_volume = gcorelabs.Volume("first_volume",
        name="boot volume",
        type_name="ssd_hiiops",
        size=6,
        image_id="f4ce3d30-e29c-4cfd-811f-46f383b6081f",
        region_id=1,
        project_id=1)
    second_volume = gcorelabs.Volume("second_volume",
        name="second volume",
        type_name="ssd_hiiops",
        image_id="f4ce3d30-e29c-4cfd-811f-46f383b6081f",
        size=6,
        region_id=1,
        project_id=1)
    third_volume = gcorelabs.Volume("third_volume",
        name="third volume",
        type_name="ssd_hiiops",
        size=6,
        region_id=1,
        project_id=1)
    instance = gcorelabs.Instance("instance",
        flavor_id="g1-standard-2-4",
        name="test",
        keypair_name=kp.sshkey_name,
        volumes=[{
            "source": "existing-volume",
            "volume_id": first_volume.volume_id,
            "boot_index": 0,
        }],
        interfaces=[
            {
                "type": "subnet",
                "network_id": network.network_id,
                "subnet_id": subnet.subnet_id,
            },
            {
                "type": "subnet",
                "network_id": network.network_id,
                "subnet_id": subnet2.subnet_id,
            },
        ],
        security_groups=[{
            "id": "66988147-f1b9-43b2-aaef-dee6d009b5b7",
            "name": "default",
        }],
        metadatas=[{
            "key": "some_key",
            "value": "some_data",
        }],
        configurations=[{
            "key": "some_key",
            "value": "some_data",
        }],
        region_id=1,
        project_id=1)
    lb = gcorelabs.Loadbalancer("lb",
        project_id=1,
        region_id=1,
        name="test1",
        flavor="lb1-1-2",
        listener={
            "name": "test",
            "protocol": "HTTP",
            "protocol_port": 80,
        })
    pl = gcorelabs.Lbpool("pl",
        project_id=1,
        region_id=1,
        name="test_pool1",
        protocol="HTTP",
        lb_algorithm="LEAST_CONNECTIONS",
        loadbalancer_id=lb.loadbalancer_id,
        listener_id=lb.listener.id,
        health_monitor={
            "type": "PING",
            "delay": 60,
            "max_retries": 5,
            "timeout": 10,
        },
        session_persistence={
            "type": "APP_COOKIE",
            "cookie_name": "test_new_cookie",
        })
    lbm = gcorelabs.Lbmember("lbm",
        project_id=1,
        region_id=1,
        pool_id=pl.lbpool_id,
        instance_id=instance.instance_id,
        address=instance.interfaces[0].ip_address,
        protocol_port=8081,
        weight=5)
    instance2 = gcorelabs.Instance("instance2",
        flavor_id="g1-standard-2-4",
        name="test2",
        keypair_name=kp.sshkey_name,
        volumes=[
            {
                "source": "existing-volume",
                "volume_id": second_volume.volume_id,
                "boot_index": 0,
            },
            {
                "source": "existing-volume",
                "volume_id": third_volume.volume_id,
                "boot_index": 1,
            },
        ],
        interfaces=[{
            "type": "subnet",
            "network_id": network.network_id,
            "subnet_id": subnet.subnet_id,
        }],
        security_groups=[{
            "id": "66988147-f1b9-43b2-aaef-dee6d009b5b7",
            "name": "default",
        }],
        metadatas=[{
            "key": "some_key",
            "value": "some_data",
        }],
        configurations=[{
            "key": "some_key",
            "value": "some_data",
        }],
        region_id=1,
        project_id=1)
    lbm2 = gcorelabs.Lbmember("lbm2",
        project_id=1,
        region_id=1,
        pool_id=pl.lbpool_id,
        instance_id=instance2.instance_id,
        address=instance2.interfaces[0].ip_address,
        protocol_port=8081,
        weight=5)
    
    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: dotnet
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcorelabs = Pulumi.Gcorelabs;
    
    return await Deployment.RunAsync(() =>
    {
        var kp = new Gcorelabs.Keypair("kp", new()
        {
            ProjectId = 1,
            PublicKey = "your oub key",
            SshkeyName = "testkey",
        });
    
        var network = new Gcorelabs.Network("network", new()
        {
            Name = "network_example",
            Mtu = 1450,
            Type = "vxlan",
            RegionId = 1,
            ProjectId = 1,
        });
    
        var subnet = new Gcorelabs.Subnet("subnet", new()
        {
            Name = "subnet_example",
            Cidr = "192.168.10.0/24",
            NetworkId = network.NetworkId,
            DnsNameservers = new[]
            {
                "8.8.4.4",
                "1.1.1.1",
            },
            HostRoutes = new[]
            {
                new Gcorelabs.Inputs.SubnetHostRouteArgs
                {
                    Destination = "10.0.3.0/24",
                    Nexthop = "10.0.0.13",
                },
            },
            GatewayIp = "192.168.10.1",
            RegionId = 1,
            ProjectId = 1,
        });
    
        var subnet2 = new Gcorelabs.Subnet("subnet2", new()
        {
            Name = "subnet2_example",
            Cidr = "192.168.20.0/24",
            NetworkId = network.NetworkId,
            DnsNameservers = new[]
            {
                "8.8.4.4",
                "1.1.1.1",
            },
            HostRoutes = new[]
            {
                new Gcorelabs.Inputs.SubnetHostRouteArgs
                {
                    Destination = "10.0.3.0/24",
                    Nexthop = "10.0.0.13",
                },
            },
            GatewayIp = "192.168.20.1",
            RegionId = 1,
            ProjectId = 1,
        });
    
        var firstVolume = new Gcorelabs.Volume("first_volume", new()
        {
            Name = "boot volume",
            TypeName = "ssd_hiiops",
            Size = 6,
            ImageId = "f4ce3d30-e29c-4cfd-811f-46f383b6081f",
            RegionId = 1,
            ProjectId = 1,
        });
    
        var secondVolume = new Gcorelabs.Volume("second_volume", new()
        {
            Name = "second volume",
            TypeName = "ssd_hiiops",
            ImageId = "f4ce3d30-e29c-4cfd-811f-46f383b6081f",
            Size = 6,
            RegionId = 1,
            ProjectId = 1,
        });
    
        var thirdVolume = new Gcorelabs.Volume("third_volume", new()
        {
            Name = "third volume",
            TypeName = "ssd_hiiops",
            Size = 6,
            RegionId = 1,
            ProjectId = 1,
        });
    
        var instance = new Gcorelabs.Instance("instance", new()
        {
            FlavorId = "g1-standard-2-4",
            Name = "test",
            KeypairName = kp.SshkeyName,
            Volumes = new[]
            {
                new Gcorelabs.Inputs.InstanceVolumeArgs
                {
                    Source = "existing-volume",
                    VolumeId = firstVolume.VolumeId,
                    BootIndex = 0,
                },
            },
            Interfaces = new[]
            {
                new Gcorelabs.Inputs.InstanceInterfaceArgs
                {
                    Type = "subnet",
                    NetworkId = network.NetworkId,
                    SubnetId = subnet.SubnetId,
                },
                new Gcorelabs.Inputs.InstanceInterfaceArgs
                {
                    Type = "subnet",
                    NetworkId = network.NetworkId,
                    SubnetId = subnet2.SubnetId,
                },
            },
            SecurityGroups = new[]
            {
                new Gcorelabs.Inputs.InstanceSecurityGroupArgs
                {
                    Id = "66988147-f1b9-43b2-aaef-dee6d009b5b7",
                    Name = "default",
                },
            },
            Metadatas = new[]
            {
                new Gcorelabs.Inputs.InstanceMetadataArgs
                {
                    Key = "some_key",
                    Value = "some_data",
                },
            },
            Configurations = new[]
            {
                new Gcorelabs.Inputs.InstanceConfigurationArgs
                {
                    Key = "some_key",
                    Value = "some_data",
                },
            },
            RegionId = 1,
            ProjectId = 1,
        });
    
        var lb = new Gcorelabs.Loadbalancer("lb", new()
        {
            ProjectId = 1,
            RegionId = 1,
            Name = "test1",
            Flavor = "lb1-1-2",
            Listener = new Gcorelabs.Inputs.LoadbalancerListenerArgs
            {
                Name = "test",
                Protocol = "HTTP",
                ProtocolPort = 80,
            },
        });
    
        var pl = new Gcorelabs.Lbpool("pl", new()
        {
            ProjectId = 1,
            RegionId = 1,
            Name = "test_pool1",
            Protocol = "HTTP",
            LbAlgorithm = "LEAST_CONNECTIONS",
            LoadbalancerId = lb.LoadbalancerId,
            ListenerId = lb.Listener.Apply(listener => listener.Id),
            HealthMonitor = new Gcorelabs.Inputs.LbpoolHealthMonitorArgs
            {
                Type = "PING",
                Delay = 60,
                MaxRetries = 5,
                Timeout = 10,
            },
            SessionPersistence = new Gcorelabs.Inputs.LbpoolSessionPersistenceArgs
            {
                Type = "APP_COOKIE",
                CookieName = "test_new_cookie",
            },
        });
    
        var lbm = new Gcorelabs.Lbmember("lbm", new()
        {
            ProjectId = 1,
            RegionId = 1,
            PoolId = pl.LbpoolId,
            InstanceId = instance.InstanceId,
            Address = instance.Interfaces.Apply(interfaces => interfaces[0].IpAddress),
            ProtocolPort = 8081,
            Weight = 5,
        });
    
        var instance2 = new Gcorelabs.Instance("instance2", new()
        {
            FlavorId = "g1-standard-2-4",
            Name = "test2",
            KeypairName = kp.SshkeyName,
            Volumes = new[]
            {
                new Gcorelabs.Inputs.InstanceVolumeArgs
                {
                    Source = "existing-volume",
                    VolumeId = secondVolume.VolumeId,
                    BootIndex = 0,
                },
                new Gcorelabs.Inputs.InstanceVolumeArgs
                {
                    Source = "existing-volume",
                    VolumeId = thirdVolume.VolumeId,
                    BootIndex = 1,
                },
            },
            Interfaces = new[]
            {
                new Gcorelabs.Inputs.InstanceInterfaceArgs
                {
                    Type = "subnet",
                    NetworkId = network.NetworkId,
                    SubnetId = subnet.SubnetId,
                },
            },
            SecurityGroups = new[]
            {
                new Gcorelabs.Inputs.InstanceSecurityGroupArgs
                {
                    Id = "66988147-f1b9-43b2-aaef-dee6d009b5b7",
                    Name = "default",
                },
            },
            Metadatas = new[]
            {
                new Gcorelabs.Inputs.InstanceMetadataArgs
                {
                    Key = "some_key",
                    Value = "some_data",
                },
            },
            Configurations = new[]
            {
                new Gcorelabs.Inputs.InstanceConfigurationArgs
                {
                    Key = "some_key",
                    Value = "some_data",
                },
            },
            RegionId = 1,
            ProjectId = 1,
        });
    
        var lbm2 = new Gcorelabs.Lbmember("lbm2", new()
        {
            ProjectId = 1,
            RegionId = 1,
            PoolId = pl.LbpoolId,
            InstanceId = instance2.InstanceId,
            Address = instance2.Interfaces.Apply(interfaces => interfaces[0].IpAddress),
            ProtocolPort = 8081,
            Weight = 5,
        });
    
    });
    
    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: go
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-pulumi-provider/sdks/go/gcorelabs/gcorelabs"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		kp, err := gcorelabs.NewKeypair(ctx, "kp", &gcorelabs.KeypairArgs{
    			ProjectId:  pulumi.Float64(1),
    			PublicKey:  pulumi.String("your oub key"),
    			SshkeyName: pulumi.String("testkey"),
    		})
    		if err != nil {
    			return err
    		}
    		network, err := gcorelabs.NewNetwork(ctx, "network", &gcorelabs.NetworkArgs{
    			Name:      pulumi.String("network_example"),
    			Mtu:       pulumi.Float64(1450),
    			Type:      pulumi.String("vxlan"),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		subnet, err := gcorelabs.NewSubnet(ctx, "subnet", &gcorelabs.SubnetArgs{
    			Name:      pulumi.String("subnet_example"),
    			Cidr:      pulumi.String("192.168.10.0/24"),
    			NetworkId: network.NetworkId,
    			DnsNameservers: pulumi.StringArray{
    				pulumi.String("8.8.4.4"),
    				pulumi.String("1.1.1.1"),
    			},
    			HostRoutes: gcorelabs.SubnetHostRouteArray{
    				&gcorelabs.SubnetHostRouteArgs{
    					Destination: pulumi.String("10.0.3.0/24"),
    					Nexthop:     pulumi.String("10.0.0.13"),
    				},
    			},
    			GatewayIp: pulumi.String("192.168.10.1"),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		subnet2, err := gcorelabs.NewSubnet(ctx, "subnet2", &gcorelabs.SubnetArgs{
    			Name:      pulumi.String("subnet2_example"),
    			Cidr:      pulumi.String("192.168.20.0/24"),
    			NetworkId: network.NetworkId,
    			DnsNameservers: pulumi.StringArray{
    				pulumi.String("8.8.4.4"),
    				pulumi.String("1.1.1.1"),
    			},
    			HostRoutes: gcorelabs.SubnetHostRouteArray{
    				&gcorelabs.SubnetHostRouteArgs{
    					Destination: pulumi.String("10.0.3.0/24"),
    					Nexthop:     pulumi.String("10.0.0.13"),
    				},
    			},
    			GatewayIp: pulumi.String("192.168.20.1"),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		firstVolume, err := gcorelabs.NewVolume(ctx, "first_volume", &gcorelabs.VolumeArgs{
    			Name:      pulumi.String("boot volume"),
    			TypeName:  pulumi.String("ssd_hiiops"),
    			Size:      pulumi.Float64(6),
    			ImageId:   pulumi.String("f4ce3d30-e29c-4cfd-811f-46f383b6081f"),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		secondVolume, err := gcorelabs.NewVolume(ctx, "second_volume", &gcorelabs.VolumeArgs{
    			Name:      pulumi.String("second volume"),
    			TypeName:  pulumi.String("ssd_hiiops"),
    			ImageId:   pulumi.String("f4ce3d30-e29c-4cfd-811f-46f383b6081f"),
    			Size:      pulumi.Float64(6),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		thirdVolume, err := gcorelabs.NewVolume(ctx, "third_volume", &gcorelabs.VolumeArgs{
    			Name:      pulumi.String("third volume"),
    			TypeName:  pulumi.String("ssd_hiiops"),
    			Size:      pulumi.Float64(6),
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		instance, err := gcorelabs.NewInstance(ctx, "instance", &gcorelabs.InstanceArgs{
    			FlavorId:    pulumi.String("g1-standard-2-4"),
    			Name:        pulumi.String("test"),
    			KeypairName: kp.SshkeyName,
    			Volumes: gcorelabs.InstanceVolumeArray{
    				&gcorelabs.InstanceVolumeArgs{
    					Source:    pulumi.String("existing-volume"),
    					VolumeId:  firstVolume.VolumeId,
    					BootIndex: pulumi.Float64(0),
    				},
    			},
    			Interfaces: gcorelabs.InstanceInterfaceArray{
    				&gcorelabs.InstanceInterfaceArgs{
    					Type:      pulumi.String("subnet"),
    					NetworkId: network.NetworkId,
    					SubnetId:  subnet.SubnetId,
    				},
    				&gcorelabs.InstanceInterfaceArgs{
    					Type:      pulumi.String("subnet"),
    					NetworkId: network.NetworkId,
    					SubnetId:  subnet2.SubnetId,
    				},
    			},
    			SecurityGroups: gcorelabs.InstanceSecurityGroupArray{
    				&gcorelabs.InstanceSecurityGroupArgs{
    					Id:   pulumi.String("66988147-f1b9-43b2-aaef-dee6d009b5b7"),
    					Name: pulumi.String("default"),
    				},
    			},
    			Metadatas: gcorelabs.InstanceMetadataArray{
    				&gcorelabs.InstanceMetadataArgs{
    					Key:   pulumi.String("some_key"),
    					Value: pulumi.String("some_data"),
    				},
    			},
    			Configurations: gcorelabs.InstanceConfigurationArray{
    				&gcorelabs.InstanceConfigurationArgs{
    					Key:   pulumi.String("some_key"),
    					Value: pulumi.String("some_data"),
    				},
    			},
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		lb, err := gcorelabs.NewLoadbalancer(ctx, "lb", &gcorelabs.LoadbalancerArgs{
    			ProjectId: pulumi.Float64(1),
    			RegionId:  pulumi.Float64(1),
    			Name:      pulumi.String("test1"),
    			Flavor:    pulumi.String("lb1-1-2"),
    			Listener: &gcorelabs.LoadbalancerListenerArgs{
    				Name:         pulumi.String("test"),
    				Protocol:     pulumi.String("HTTP"),
    				ProtocolPort: pulumi.Float64(80),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		pl, err := gcorelabs.NewLbpool(ctx, "pl", &gcorelabs.LbpoolArgs{
    			ProjectId:      pulumi.Float64(1),
    			RegionId:       pulumi.Float64(1),
    			Name:           pulumi.String("test_pool1"),
    			Protocol:       pulumi.String("HTTP"),
    			LbAlgorithm:    pulumi.String("LEAST_CONNECTIONS"),
    			LoadbalancerId: lb.LoadbalancerId,
    			ListenerId: pulumi.String(lb.Listener.ApplyT(func(listener gcorelabs.LoadbalancerListener) (*string, error) {
    				return &listener.Id, nil
    			}).(pulumi.StringPtrOutput)),
    			HealthMonitor: &gcorelabs.LbpoolHealthMonitorArgs{
    				Type:       pulumi.String("PING"),
    				Delay:      pulumi.Float64(60),
    				MaxRetries: pulumi.Float64(5),
    				Timeout:    pulumi.Float64(10),
    			},
    			SessionPersistence: &gcorelabs.LbpoolSessionPersistenceArgs{
    				Type:       pulumi.String("APP_COOKIE"),
    				CookieName: pulumi.String("test_new_cookie"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = gcorelabs.NewLbmember(ctx, "lbm", &gcorelabs.LbmemberArgs{
    			ProjectId:  pulumi.Float64(1),
    			RegionId:   pulumi.Float64(1),
    			PoolId:     pl.LbpoolId,
    			InstanceId: instance.InstanceId,
    			Address: pulumi.String(instance.Interfaces.ApplyT(func(interfaces []gcorelabs.InstanceInterface) (*string, error) {
    				return &interfaces[0].IpAddress, nil
    			}).(pulumi.StringPtrOutput)),
    			ProtocolPort: pulumi.Float64(8081),
    			Weight:       pulumi.Float64(5),
    		})
    		if err != nil {
    			return err
    		}
    		instance2, err := gcorelabs.NewInstance(ctx, "instance2", &gcorelabs.InstanceArgs{
    			FlavorId:    pulumi.String("g1-standard-2-4"),
    			Name:        pulumi.String("test2"),
    			KeypairName: kp.SshkeyName,
    			Volumes: gcorelabs.InstanceVolumeArray{
    				&gcorelabs.InstanceVolumeArgs{
    					Source:    pulumi.String("existing-volume"),
    					VolumeId:  secondVolume.VolumeId,
    					BootIndex: pulumi.Float64(0),
    				},
    				&gcorelabs.InstanceVolumeArgs{
    					Source:    pulumi.String("existing-volume"),
    					VolumeId:  thirdVolume.VolumeId,
    					BootIndex: pulumi.Float64(1),
    				},
    			},
    			Interfaces: gcorelabs.InstanceInterfaceArray{
    				&gcorelabs.InstanceInterfaceArgs{
    					Type:      pulumi.String("subnet"),
    					NetworkId: network.NetworkId,
    					SubnetId:  subnet.SubnetId,
    				},
    			},
    			SecurityGroups: gcorelabs.InstanceSecurityGroupArray{
    				&gcorelabs.InstanceSecurityGroupArgs{
    					Id:   pulumi.String("66988147-f1b9-43b2-aaef-dee6d009b5b7"),
    					Name: pulumi.String("default"),
    				},
    			},
    			Metadatas: gcorelabs.InstanceMetadataArray{
    				&gcorelabs.InstanceMetadataArgs{
    					Key:   pulumi.String("some_key"),
    					Value: pulumi.String("some_data"),
    				},
    			},
    			Configurations: gcorelabs.InstanceConfigurationArray{
    				&gcorelabs.InstanceConfigurationArgs{
    					Key:   pulumi.String("some_key"),
    					Value: pulumi.String("some_data"),
    				},
    			},
    			RegionId:  pulumi.Float64(1),
    			ProjectId: pulumi.Float64(1),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = gcorelabs.NewLbmember(ctx, "lbm2", &gcorelabs.LbmemberArgs{
    			ProjectId:  pulumi.Float64(1),
    			RegionId:   pulumi.Float64(1),
    			PoolId:     pl.LbpoolId,
    			InstanceId: instance2.InstanceId,
    			Address: pulumi.String(instance2.Interfaces.ApplyT(func(interfaces []gcorelabs.InstanceInterface) (*string, error) {
    				return &interfaces[0].IpAddress, nil
    			}).(pulumi.StringPtrOutput)),
    			ProtocolPort: pulumi.Float64(8081),
    			Weight:       pulumi.Float64(5),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: yaml
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    resources:
      kp:
        type: gcorelabs:Keypair
        properties:
          projectId: 1
          publicKey: your oub key
          sshkeyName: testkey
      network:
        type: gcorelabs:Network
        properties:
          name: network_example
          mtu: 1450
          type: vxlan
          regionId: 1
          projectId: 1
      subnet:
        type: gcorelabs:Subnet
        properties:
          name: subnet_example
          cidr: 192.168.10.0/24
          networkId: ${network.networkId}
          dnsNameservers:
            - 8.8.4.4
            - 1.1.1.1
          hostRoutes:
            - destination: 10.0.3.0/24
              nexthop: 10.0.0.13
          gatewayIp: 192.168.10.1
          regionId: 1
          projectId: 1
      subnet2:
        type: gcorelabs:Subnet
        properties:
          name: subnet2_example
          cidr: 192.168.20.0/24
          networkId: ${network.networkId}
          dnsNameservers:
            - 8.8.4.4
            - 1.1.1.1
          hostRoutes:
            - destination: 10.0.3.0/24
              nexthop: 10.0.0.13
          gatewayIp: 192.168.20.1
          regionId: 1
          projectId: 1
      firstVolume:
        type: gcorelabs:Volume
        name: first_volume
        properties:
          name: boot volume
          typeName: ssd_hiiops
          size: 6
          imageId: f4ce3d30-e29c-4cfd-811f-46f383b6081f
          regionId: 1
          projectId: 1
      secondVolume:
        type: gcorelabs:Volume
        name: second_volume
        properties:
          name: second volume
          typeName: ssd_hiiops
          imageId: f4ce3d30-e29c-4cfd-811f-46f383b6081f
          size: 6
          regionId: 1
          projectId: 1
      thirdVolume:
        type: gcorelabs:Volume
        name: third_volume
        properties:
          name: third volume
          typeName: ssd_hiiops
          size: 6
          regionId: 1
          projectId: 1
      instance:
        type: gcorelabs:Instance
        properties:
          flavorId: g1-standard-2-4
          name: test
          keypairName: ${kp.sshkeyName}
          volumes:
            - source: existing-volume
              volumeId: ${firstVolume.volumeId}
              bootIndex: 0
          interfaces:
            - type: subnet
              networkId: ${network.networkId}
              subnetId: ${subnet.subnetId}
            - type: subnet
              networkId: ${network.networkId}
              subnetId: ${subnet2.subnetId}
          securityGroups:
            - id: 66988147-f1b9-43b2-aaef-dee6d009b5b7
              name: default
          metadatas:
            - key: some_key
              value: some_data
          configurations:
            - key: some_key
              value: some_data
          regionId: 1
          projectId: 1
      lb:
        type: gcorelabs:Loadbalancer
        properties:
          projectId: 1
          regionId: 1
          name: test1
          flavor: lb1-1-2
          listener:
            name: test
            protocol: HTTP
            protocolPort: 80
      pl:
        type: gcorelabs:Lbpool
        properties:
          projectId: 1
          regionId: 1
          name: test_pool1
          protocol: HTTP
          lbAlgorithm: LEAST_CONNECTIONS
          loadbalancerId: ${lb.loadbalancerId}
          listenerId: ${lb.listener.id}
          healthMonitor:
            type: PING
            delay: 60
            maxRetries: 5
            timeout: 10
          sessionPersistence:
            type: APP_COOKIE
            cookieName: test_new_cookie
      lbm:
        type: gcorelabs:Lbmember
        properties:
          projectId: 1
          regionId: 1
          poolId: ${pl.lbpoolId}
          instanceId: ${instance.instanceId}
          address: ${instance.interfaces[0].ipAddress}
          protocolPort: 8081
          weight: 5
      instance2:
        type: gcorelabs:Instance
        properties:
          flavorId: g1-standard-2-4
          name: test2
          keypairName: ${kp.sshkeyName}
          volumes:
            - source: existing-volume
              volumeId: ${secondVolume.volumeId}
              bootIndex: 0
            - source: existing-volume
              volumeId: ${thirdVolume.volumeId}
              bootIndex: 1
          interfaces:
            - type: subnet
              networkId: ${network.networkId}
              subnetId: ${subnet.subnetId}
          securityGroups:
            - id: 66988147-f1b9-43b2-aaef-dee6d009b5b7
              name: default
          metadatas:
            - key: some_key
              value: some_data
          configurations:
            - key: some_key
              value: some_data
          regionId: 1
          projectId: 1
      lbm2:
        type: gcorelabs:Lbmember
        properties:
          projectId: 1
          regionId: 1
          poolId: ${pl.lbpoolId}
          instanceId: ${instance2.instanceId}
          address: ${instance2.interfaces[0].ipAddress}
          protocolPort: 8081
          weight: 5
    
    # Pulumi.yaml provider configuration file
    name: configuration-example
    runtime: java
    config:
        gcore:permanentApiToken:
            value: 251$d3361.............1b35f26d8
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcorelabs.Keypair;
    import com.pulumi.gcorelabs.KeypairArgs;
    import com.pulumi.gcorelabs.Network;
    import com.pulumi.gcorelabs.NetworkArgs;
    import com.pulumi.gcorelabs.Subnet;
    import com.pulumi.gcorelabs.SubnetArgs;
    import com.pulumi.gcorelabs.inputs.SubnetHostRouteArgs;
    import com.pulumi.gcorelabs.Volume;
    import com.pulumi.gcorelabs.VolumeArgs;
    import com.pulumi.gcorelabs.Instance;
    import com.pulumi.gcorelabs.InstanceArgs;
    import com.pulumi.gcorelabs.inputs.InstanceVolumeArgs;
    import com.pulumi.gcorelabs.inputs.InstanceInterfaceArgs;
    import com.pulumi.gcorelabs.inputs.InstanceSecurityGroupArgs;
    import com.pulumi.gcorelabs.inputs.InstanceMetadataArgs;
    import com.pulumi.gcorelabs.inputs.InstanceConfigurationArgs;
    import com.pulumi.gcorelabs.Loadbalancer;
    import com.pulumi.gcorelabs.LoadbalancerArgs;
    import com.pulumi.gcorelabs.inputs.LoadbalancerListenerArgs;
    import com.pulumi.gcorelabs.Lbpool;
    import com.pulumi.gcorelabs.LbpoolArgs;
    import com.pulumi.gcorelabs.inputs.LbpoolHealthMonitorArgs;
    import com.pulumi.gcorelabs.inputs.LbpoolSessionPersistenceArgs;
    import com.pulumi.gcorelabs.Lbmember;
    import com.pulumi.gcorelabs.LbmemberArgs;
    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 kp = new Keypair("kp", KeypairArgs.builder()
                .projectId(1)
                .publicKey("your oub key")
                .sshkeyName("testkey")
                .build());
    
            var network = new Network("network", NetworkArgs.builder()
                .name("network_example")
                .mtu(1450)
                .type("vxlan")
                .regionId(1)
                .projectId(1)
                .build());
    
            var subnet = new Subnet("subnet", SubnetArgs.builder()
                .name("subnet_example")
                .cidr("192.168.10.0/24")
                .networkId(network.networkId())
                .dnsNameservers(
                    "8.8.4.4",
                    "1.1.1.1")
                .hostRoutes(SubnetHostRouteArgs.builder()
                    .destination("10.0.3.0/24")
                    .nexthop("10.0.0.13")
                    .build())
                .gatewayIp("192.168.10.1")
                .regionId(1)
                .projectId(1)
                .build());
    
            var subnet2 = new Subnet("subnet2", SubnetArgs.builder()
                .name("subnet2_example")
                .cidr("192.168.20.0/24")
                .networkId(network.networkId())
                .dnsNameservers(
                    "8.8.4.4",
                    "1.1.1.1")
                .hostRoutes(SubnetHostRouteArgs.builder()
                    .destination("10.0.3.0/24")
                    .nexthop("10.0.0.13")
                    .build())
                .gatewayIp("192.168.20.1")
                .regionId(1)
                .projectId(1)
                .build());
    
            var firstVolume = new Volume("firstVolume", VolumeArgs.builder()
                .name("boot volume")
                .typeName("ssd_hiiops")
                .size(6)
                .imageId("f4ce3d30-e29c-4cfd-811f-46f383b6081f")
                .regionId(1)
                .projectId(1)
                .build());
    
            var secondVolume = new Volume("secondVolume", VolumeArgs.builder()
                .name("second volume")
                .typeName("ssd_hiiops")
                .imageId("f4ce3d30-e29c-4cfd-811f-46f383b6081f")
                .size(6)
                .regionId(1)
                .projectId(1)
                .build());
    
            var thirdVolume = new Volume("thirdVolume", VolumeArgs.builder()
                .name("third volume")
                .typeName("ssd_hiiops")
                .size(6)
                .regionId(1)
                .projectId(1)
                .build());
    
            var instance = new Instance("instance", InstanceArgs.builder()
                .flavorId("g1-standard-2-4")
                .name("test")
                .keypairName(kp.sshkeyName())
                .volumes(InstanceVolumeArgs.builder()
                    .source("existing-volume")
                    .volumeId(firstVolume.volumeId())
                    .bootIndex(0)
                    .build())
                .interfaces(
                    InstanceInterfaceArgs.builder()
                        .type("subnet")
                        .networkId(network.networkId())
                        .subnetId(subnet.subnetId())
                        .build(),
                    InstanceInterfaceArgs.builder()
                        .type("subnet")
                        .networkId(network.networkId())
                        .subnetId(subnet2.subnetId())
                        .build())
                .securityGroups(InstanceSecurityGroupArgs.builder()
                    .id("66988147-f1b9-43b2-aaef-dee6d009b5b7")
                    .name("default")
                    .build())
                .metadatas(InstanceMetadataArgs.builder()
                    .key("some_key")
                    .value("some_data")
                    .build())
                .configurations(InstanceConfigurationArgs.builder()
                    .key("some_key")
                    .value("some_data")
                    .build())
                .regionId(1)
                .projectId(1)
                .build());
    
            var lb = new Loadbalancer("lb", LoadbalancerArgs.builder()
                .projectId(1)
                .regionId(1)
                .name("test1")
                .flavor("lb1-1-2")
                .listener(LoadbalancerListenerArgs.builder()
                    .name("test")
                    .protocol("HTTP")
                    .protocolPort(80)
                    .build())
                .build());
    
            var pl = new Lbpool("pl", LbpoolArgs.builder()
                .projectId(1)
                .regionId(1)
                .name("test_pool1")
                .protocol("HTTP")
                .lbAlgorithm("LEAST_CONNECTIONS")
                .loadbalancerId(lb.loadbalancerId())
                .listenerId(lb.listener().applyValue(listener -> listener.id()))
                .healthMonitor(LbpoolHealthMonitorArgs.builder()
                    .type("PING")
                    .delay(60)
                    .maxRetries(5)
                    .timeout(10)
                    .build())
                .sessionPersistence(LbpoolSessionPersistenceArgs.builder()
                    .type("APP_COOKIE")
                    .cookieName("test_new_cookie")
                    .build())
                .build());
    
            var lbm = new Lbmember("lbm", LbmemberArgs.builder()
                .projectId(1)
                .regionId(1)
                .poolId(pl.lbpoolId())
                .instanceId(instance.instanceId())
                .address(instance.interfaces().applyValue(interfaces -> interfaces[0].ipAddress()))
                .protocolPort(8081)
                .weight(5)
                .build());
    
            var instance2 = new Instance("instance2", InstanceArgs.builder()
                .flavorId("g1-standard-2-4")
                .name("test2")
                .keypairName(kp.sshkeyName())
                .volumes(
                    InstanceVolumeArgs.builder()
                        .source("existing-volume")
                        .volumeId(secondVolume.volumeId())
                        .bootIndex(0)
                        .build(),
                    InstanceVolumeArgs.builder()
                        .source("existing-volume")
                        .volumeId(thirdVolume.volumeId())
                        .bootIndex(1)
                        .build())
                .interfaces(InstanceInterfaceArgs.builder()
                    .type("subnet")
                    .networkId(network.networkId())
                    .subnetId(subnet.subnetId())
                    .build())
                .securityGroups(InstanceSecurityGroupArgs.builder()
                    .id("66988147-f1b9-43b2-aaef-dee6d009b5b7")
                    .name("default")
                    .build())
                .metadatas(InstanceMetadataArgs.builder()
                    .key("some_key")
                    .value("some_data")
                    .build())
                .configurations(InstanceConfigurationArgs.builder()
                    .key("some_key")
                    .value("some_data")
                    .build())
                .regionId(1)
                .projectId(1)
                .build());
    
            var lbm2 = new Lbmember("lbm2", LbmemberArgs.builder()
                .projectId(1)
                .regionId(1)
                .poolId(pl.lbpoolId())
                .instanceId(instance2.instanceId())
                .address(instance2.interfaces().applyValue(interfaces -> interfaces[0].ipAddress()))
                .protocolPort(8081)
                .weight(5)
                .build());
    
        }
    }
    

    Configuration Reference

    • apiEndpoint (String) A single API endpoint for all products. Will be used when specific product API url is not defined.
    • gcoreApi (String, Deprecated) Region API
    • gcoreCdnApi (String) CDN API (define only if you want to override CDN API endpoint)
    • gcoreClientId (String) Client id
    • gcoreCloudApi (String) Region API (define only if you want to override Region API endpoint)
    • gcoreDnsApi (String) DNS API (define only if you want to override DNS API endpoint)
    • gcorePlatform (String, Deprecated) Platform URL is used for generate JWT
    • gcorePlatformApi (String) Platform URL is used for generate JWT (define only if you want to override Platform API endpoint)
    • gcoreStorageApi (String) Storage API (define only if you want to override Storage API endpoint)
    • ignoreCredsAuthError (Boolean, Deprecated) Should be set to true when you are gonna to use storage resource with permanent API-token only.
    • password (String, Deprecated)
    • permanentApiToken (String, Sensitive) A permanent API-token
    • userName (String, Deprecated)
    gcorelabs logo
    gcorelabs 0.3.63 published on Monday, Apr 14, 2025 by g-core