1. Packages
  2. Scaleway
  3. API Docs
  4. RedisCluster
Scaleway v1.10.0 published on Saturday, Jul 1, 2023 by lbrlabs

scaleway.RedisCluster

Explore with Pulumi AI

scaleway logo
Scaleway v1.10.0 published on Saturday, Jul 1, 2023 by lbrlabs

    Creates and manages Scaleway Redis Clusters. For more information, see the documentation.

    Examples

    Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as scaleway from "@lbrlabs/pulumi-scaleway";
    
    const main = new scaleway.RedisCluster("main", {
        acls: [{
            description: "Allow all",
            ip: "0.0.0.0/0",
        }],
        clusterSize: 1,
        nodeType: "RED1-MICRO",
        password: "thiZ_is_v&ry_s3cret",
        tags: [
            "test",
            "redis",
        ],
        tlsEnabled: true,
        userName: "my_initial_user",
        version: "6.2.6",
    });
    
    import pulumi
    import lbrlabs_pulumi_scaleway as scaleway
    
    main = scaleway.RedisCluster("main",
        acls=[scaleway.RedisClusterAclArgs(
            description="Allow all",
            ip="0.0.0.0/0",
        )],
        cluster_size=1,
        node_type="RED1-MICRO",
        password="thiZ_is_v&ry_s3cret",
        tags=[
            "test",
            "redis",
        ],
        tls_enabled=True,
        user_name="my_initial_user",
        version="6.2.6")
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Scaleway = Lbrlabs.PulumiPackage.Scaleway;
    
    return await Deployment.RunAsync(() => 
    {
        var main = new Scaleway.RedisCluster("main", new()
        {
            Acls = new[]
            {
                new Scaleway.Inputs.RedisClusterAclArgs
                {
                    Description = "Allow all",
                    Ip = "0.0.0.0/0",
                },
            },
            ClusterSize = 1,
            NodeType = "RED1-MICRO",
            Password = "thiZ_is_v&ry_s3cret",
            Tags = new[]
            {
                "test",
                "redis",
            },
            TlsEnabled = true,
            UserName = "my_initial_user",
            Version = "6.2.6",
        });
    
    });
    
    package main
    
    import (
    	"github.com/lbrlabs/pulumi-scaleway/sdk/go/scaleway"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := scaleway.NewRedisCluster(ctx, "main", &scaleway.RedisClusterArgs{
    			Acls: scaleway.RedisClusterAclArray{
    				&scaleway.RedisClusterAclArgs{
    					Description: pulumi.String("Allow all"),
    					Ip:          pulumi.String("0.0.0.0/0"),
    				},
    			},
    			ClusterSize: pulumi.Int(1),
    			NodeType:    pulumi.String("RED1-MICRO"),
    			Password:    pulumi.String("thiZ_is_v&ry_s3cret"),
    			Tags: pulumi.StringArray{
    				pulumi.String("test"),
    				pulumi.String("redis"),
    			},
    			TlsEnabled: pulumi.Bool(true),
    			UserName:   pulumi.String("my_initial_user"),
    			Version:    pulumi.String("6.2.6"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.scaleway.RedisCluster;
    import com.pulumi.scaleway.RedisClusterArgs;
    import com.pulumi.scaleway.inputs.RedisClusterAclArgs;
    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 main = new RedisCluster("main", RedisClusterArgs.builder()        
                .acls(RedisClusterAclArgs.builder()
                    .description("Allow all")
                    .ip("0.0.0.0/0")
                    .build())
                .clusterSize(1)
                .nodeType("RED1-MICRO")
                .password("thiZ_is_v&ry_s3cret")
                .tags(            
                    "test",
                    "redis")
                .tlsEnabled("true")
                .userName("my_initial_user")
                .version("6.2.6")
                .build());
    
        }
    }
    
    resources:
      main:
        type: scaleway:RedisCluster
        properties:
          acls:
            - description: Allow all
              ip: 0.0.0.0/0
          clusterSize: 1
          nodeType: RED1-MICRO
          password: thiZ_is_v&ry_s3cret
          tags:
            - test
            - redis
          tlsEnabled: 'true'
          userName: my_initial_user
          version: 6.2.6
    

    With settings

    import * as pulumi from "@pulumi/pulumi";
    import * as scaleway from "@lbrlabs/pulumi-scaleway";
    
    const main = new scaleway.RedisCluster("main", {
        nodeType: "RED1-MICRO",
        password: "thiZ_is_v&ry_s3cret",
        settings: {
            maxclients: "1000",
            "tcp-keepalive": "120",
        },
        userName: "my_initial_user",
        version: "6.2.6",
    });
    
    import pulumi
    import lbrlabs_pulumi_scaleway as scaleway
    
    main = scaleway.RedisCluster("main",
        node_type="RED1-MICRO",
        password="thiZ_is_v&ry_s3cret",
        settings={
            "maxclients": "1000",
            "tcp-keepalive": "120",
        },
        user_name="my_initial_user",
        version="6.2.6")
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Scaleway = Lbrlabs.PulumiPackage.Scaleway;
    
    return await Deployment.RunAsync(() => 
    {
        var main = new Scaleway.RedisCluster("main", new()
        {
            NodeType = "RED1-MICRO",
            Password = "thiZ_is_v&ry_s3cret",
            Settings = 
            {
                { "maxclients", "1000" },
                { "tcp-keepalive", "120" },
            },
            UserName = "my_initial_user",
            Version = "6.2.6",
        });
    
    });
    
    package main
    
    import (
    	"github.com/lbrlabs/pulumi-scaleway/sdk/go/scaleway"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := scaleway.NewRedisCluster(ctx, "main", &scaleway.RedisClusterArgs{
    			NodeType: pulumi.String("RED1-MICRO"),
    			Password: pulumi.String("thiZ_is_v&ry_s3cret"),
    			Settings: pulumi.StringMap{
    				"maxclients":    pulumi.String("1000"),
    				"tcp-keepalive": pulumi.String("120"),
    			},
    			UserName: pulumi.String("my_initial_user"),
    			Version:  pulumi.String("6.2.6"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.scaleway.RedisCluster;
    import com.pulumi.scaleway.RedisClusterArgs;
    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 main = new RedisCluster("main", RedisClusterArgs.builder()        
                .nodeType("RED1-MICRO")
                .password("thiZ_is_v&ry_s3cret")
                .settings(Map.ofEntries(
                    Map.entry("maxclients", "1000"),
                    Map.entry("tcp-keepalive", "120")
                ))
                .userName("my_initial_user")
                .version("6.2.6")
                .build());
    
        }
    }
    
    resources:
      main:
        type: scaleway:RedisCluster
        properties:
          nodeType: RED1-MICRO
          password: thiZ_is_v&ry_s3cret
          settings:
            maxclients: '1000'
            tcp-keepalive: '120'
          userName: my_initial_user
          version: 6.2.6
    

    With a private network

    import * as pulumi from "@pulumi/pulumi";
    import * as scaleway from "@lbrlabs/pulumi-scaleway";
    
    const pn = new scaleway.VpcPrivateNetwork("pn", {});
    const main = new scaleway.RedisCluster("main", {
        version: "6.2.6",
        nodeType: "RED1-MICRO",
        userName: "my_initial_user",
        password: "thiZ_is_v&ry_s3cret",
        clusterSize: 1,
        privateNetworks: [{
            id: pn.id,
            serviceIps: ["10.12.1.1/20"],
        }],
    }, {
        dependsOn: [pn],
    });
    
    import pulumi
    import lbrlabs_pulumi_scaleway as scaleway
    
    pn = scaleway.VpcPrivateNetwork("pn")
    main = scaleway.RedisCluster("main",
        version="6.2.6",
        node_type="RED1-MICRO",
        user_name="my_initial_user",
        password="thiZ_is_v&ry_s3cret",
        cluster_size=1,
        private_networks=[scaleway.RedisClusterPrivateNetworkArgs(
            id=pn.id,
            service_ips=["10.12.1.1/20"],
        )],
        opts=pulumi.ResourceOptions(depends_on=[pn]))
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Scaleway = Lbrlabs.PulumiPackage.Scaleway;
    
    return await Deployment.RunAsync(() => 
    {
        var pn = new Scaleway.VpcPrivateNetwork("pn");
    
        var main = new Scaleway.RedisCluster("main", new()
        {
            Version = "6.2.6",
            NodeType = "RED1-MICRO",
            UserName = "my_initial_user",
            Password = "thiZ_is_v&ry_s3cret",
            ClusterSize = 1,
            PrivateNetworks = new[]
            {
                new Scaleway.Inputs.RedisClusterPrivateNetworkArgs
                {
                    Id = pn.Id,
                    ServiceIps = new[]
                    {
                        "10.12.1.1/20",
                    },
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn = new[]
            {
                pn,
            },
        });
    
    });
    
    package main
    
    import (
    	"github.com/lbrlabs/pulumi-scaleway/sdk/go/scaleway"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		pn, err := scaleway.NewVpcPrivateNetwork(ctx, "pn", nil)
    		if err != nil {
    			return err
    		}
    		_, err = scaleway.NewRedisCluster(ctx, "main", &scaleway.RedisClusterArgs{
    			Version:     pulumi.String("6.2.6"),
    			NodeType:    pulumi.String("RED1-MICRO"),
    			UserName:    pulumi.String("my_initial_user"),
    			Password:    pulumi.String("thiZ_is_v&ry_s3cret"),
    			ClusterSize: pulumi.Int(1),
    			PrivateNetworks: scaleway.RedisClusterPrivateNetworkArray{
    				&scaleway.RedisClusterPrivateNetworkArgs{
    					Id: pn.ID(),
    					ServiceIps: pulumi.StringArray{
    						pulumi.String("10.12.1.1/20"),
    					},
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			pn,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.scaleway.VpcPrivateNetwork;
    import com.pulumi.scaleway.RedisCluster;
    import com.pulumi.scaleway.RedisClusterArgs;
    import com.pulumi.scaleway.inputs.RedisClusterPrivateNetworkArgs;
    import com.pulumi.resources.CustomResourceOptions;
    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 pn = new VpcPrivateNetwork("pn");
    
            var main = new RedisCluster("main", RedisClusterArgs.builder()        
                .version("6.2.6")
                .nodeType("RED1-MICRO")
                .userName("my_initial_user")
                .password("thiZ_is_v&ry_s3cret")
                .clusterSize(1)
                .privateNetworks(RedisClusterPrivateNetworkArgs.builder()
                    .id(pn.id())
                    .serviceIps("10.12.1.1/20")
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(pn)
                    .build());
    
        }
    }
    
    resources:
      pn:
        type: scaleway:VpcPrivateNetwork
      main:
        type: scaleway:RedisCluster
        properties:
          version: 6.2.6
          nodeType: RED1-MICRO
          userName: my_initial_user
          password: thiZ_is_v&ry_s3cret
          clusterSize: 1
          privateNetworks:
            - id: ${pn.id}
              serviceIps:
                - 10.12.1.1/20
        options:
          dependson:
            - ${pn}
    

    Create RedisCluster Resource

    new RedisCluster(name: string, args: RedisClusterArgs, opts?: CustomResourceOptions);
    @overload
    def RedisCluster(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     acls: Optional[Sequence[RedisClusterAclArgs]] = None,
                     cluster_size: Optional[int] = None,
                     name: Optional[str] = None,
                     node_type: Optional[str] = None,
                     password: Optional[str] = None,
                     private_networks: Optional[Sequence[RedisClusterPrivateNetworkArgs]] = None,
                     project_id: Optional[str] = None,
                     public_network: Optional[RedisClusterPublicNetworkArgs] = None,
                     settings: Optional[Mapping[str, str]] = None,
                     tags: Optional[Sequence[str]] = None,
                     tls_enabled: Optional[bool] = None,
                     user_name: Optional[str] = None,
                     version: Optional[str] = None,
                     zone: Optional[str] = None)
    @overload
    def RedisCluster(resource_name: str,
                     args: RedisClusterArgs,
                     opts: Optional[ResourceOptions] = None)
    func NewRedisCluster(ctx *Context, name string, args RedisClusterArgs, opts ...ResourceOption) (*RedisCluster, error)
    public RedisCluster(string name, RedisClusterArgs args, CustomResourceOptions? opts = null)
    public RedisCluster(String name, RedisClusterArgs args)
    public RedisCluster(String name, RedisClusterArgs args, CustomResourceOptions options)
    
    type: scaleway:RedisCluster
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args RedisClusterArgs
    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 RedisClusterArgs
    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 RedisClusterArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RedisClusterArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RedisClusterArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    RedisCluster Resource Properties

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

    Inputs

    The RedisCluster resource accepts the following input properties:

    NodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    Password string

    Password for the first user of the Redis Cluster.

    UserName string

    Identifier for the first user of the Redis Cluster.

    Version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    Acls List<Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterAcl>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    ClusterSize int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    Name string

    The name of the Redis Cluster.

    PrivateNetworks List<Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterPrivateNetwork>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    ProjectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    PublicNetwork Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    Settings Dictionary<string, string>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    Tags List<string>

    The tags associated with the Redis Cluster.

    TlsEnabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    NodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    Password string

    Password for the first user of the Redis Cluster.

    UserName string

    Identifier for the first user of the Redis Cluster.

    Version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    Acls []RedisClusterAclArgs

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    ClusterSize int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    Name string

    The name of the Redis Cluster.

    PrivateNetworks []RedisClusterPrivateNetworkArgs

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    ProjectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    PublicNetwork RedisClusterPublicNetworkArgs

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    Settings map[string]string

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    Tags []string

    The tags associated with the Redis Cluster.

    TlsEnabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    nodeType String

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password String

    Password for the first user of the Redis Cluster.

    userName String

    Identifier for the first user of the Redis Cluster.

    version String

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    acls List<RedisClusterAcl>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    clusterSize Integer

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    name String

    The name of the Redis Cluster.

    privateNetworks List<RedisClusterPrivateNetwork>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId String

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Map<String,String>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags List<String>

    The tags associated with the Redis Cluster.

    tlsEnabled Boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    nodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password string

    Password for the first user of the Redis Cluster.

    userName string

    Identifier for the first user of the Redis Cluster.

    version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    acls RedisClusterAcl[]

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    clusterSize number

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    name string

    The name of the Redis Cluster.

    privateNetworks RedisClusterPrivateNetwork[]

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings {[key: string]: string}

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags string[]

    The tags associated with the Redis Cluster.

    tlsEnabled boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    zone string

    zone) The zone in which the Redis Cluster should be created.

    node_type str

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password str

    Password for the first user of the Redis Cluster.

    user_name str

    Identifier for the first user of the Redis Cluster.

    version str

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    acls Sequence[RedisClusterAclArgs]

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    cluster_size int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    name str

    The name of the Redis Cluster.

    private_networks Sequence[RedisClusterPrivateNetworkArgs]

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    project_id str

    project_id) The ID of the project the Redis Cluster is associated with.

    public_network RedisClusterPublicNetworkArgs

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Mapping[str, str]

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags Sequence[str]

    The tags associated with the Redis Cluster.

    tls_enabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    zone str

    zone) The zone in which the Redis Cluster should be created.

    nodeType String

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password String

    Password for the first user of the Redis Cluster.

    userName String

    Identifier for the first user of the Redis Cluster.

    version String

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    acls List<Property Map>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    clusterSize Number

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    name String

    The name of the Redis Cluster.

    privateNetworks List<Property Map>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId String

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork Property Map

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Map<String>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags List<String>

    The tags associated with the Redis Cluster.

    tlsEnabled Boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    Outputs

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

    Certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    CreatedAt string

    The date and time of creation of the Redis Cluster.

    Id string

    The provider-assigned unique ID for this managed resource.

    UpdatedAt string

    The date and time of the last update of the Redis Cluster.

    Certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    CreatedAt string

    The date and time of creation of the Redis Cluster.

    Id string

    The provider-assigned unique ID for this managed resource.

    UpdatedAt string

    The date and time of the last update of the Redis Cluster.

    certificate String

    The PEM of the certificate used by redis, only when tls_enabled is true

    createdAt String

    The date and time of creation of the Redis Cluster.

    id String

    The provider-assigned unique ID for this managed resource.

    updatedAt String

    The date and time of the last update of the Redis Cluster.

    certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    createdAt string

    The date and time of creation of the Redis Cluster.

    id string

    The provider-assigned unique ID for this managed resource.

    updatedAt string

    The date and time of the last update of the Redis Cluster.

    certificate str

    The PEM of the certificate used by redis, only when tls_enabled is true

    created_at str

    The date and time of creation of the Redis Cluster.

    id str

    The provider-assigned unique ID for this managed resource.

    updated_at str

    The date and time of the last update of the Redis Cluster.

    certificate String

    The PEM of the certificate used by redis, only when tls_enabled is true

    createdAt String

    The date and time of creation of the Redis Cluster.

    id String

    The provider-assigned unique ID for this managed resource.

    updatedAt String

    The date and time of the last update of the Redis Cluster.

    Look up Existing RedisCluster Resource

    Get an existing RedisCluster 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?: RedisClusterState, opts?: CustomResourceOptions): RedisCluster
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            acls: Optional[Sequence[RedisClusterAclArgs]] = None,
            certificate: Optional[str] = None,
            cluster_size: Optional[int] = None,
            created_at: Optional[str] = None,
            name: Optional[str] = None,
            node_type: Optional[str] = None,
            password: Optional[str] = None,
            private_networks: Optional[Sequence[RedisClusterPrivateNetworkArgs]] = None,
            project_id: Optional[str] = None,
            public_network: Optional[RedisClusterPublicNetworkArgs] = None,
            settings: Optional[Mapping[str, str]] = None,
            tags: Optional[Sequence[str]] = None,
            tls_enabled: Optional[bool] = None,
            updated_at: Optional[str] = None,
            user_name: Optional[str] = None,
            version: Optional[str] = None,
            zone: Optional[str] = None) -> RedisCluster
    func GetRedisCluster(ctx *Context, name string, id IDInput, state *RedisClusterState, opts ...ResourceOption) (*RedisCluster, error)
    public static RedisCluster Get(string name, Input<string> id, RedisClusterState? state, CustomResourceOptions? opts = null)
    public static RedisCluster get(String name, Output<String> id, RedisClusterState 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:
    Acls List<Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterAcl>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    Certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    ClusterSize int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    CreatedAt string

    The date and time of creation of the Redis Cluster.

    Name string

    The name of the Redis Cluster.

    NodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    Password string

    Password for the first user of the Redis Cluster.

    PrivateNetworks List<Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterPrivateNetwork>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    ProjectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    PublicNetwork Lbrlabs.PulumiPackage.Scaleway.Inputs.RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    Settings Dictionary<string, string>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    Tags List<string>

    The tags associated with the Redis Cluster.

    TlsEnabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    UpdatedAt string

    The date and time of the last update of the Redis Cluster.

    UserName string

    Identifier for the first user of the Redis Cluster.

    Version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    Acls []RedisClusterAclArgs

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    Certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    ClusterSize int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    CreatedAt string

    The date and time of creation of the Redis Cluster.

    Name string

    The name of the Redis Cluster.

    NodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    Password string

    Password for the first user of the Redis Cluster.

    PrivateNetworks []RedisClusterPrivateNetworkArgs

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    ProjectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    PublicNetwork RedisClusterPublicNetworkArgs

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    Settings map[string]string

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    Tags []string

    The tags associated with the Redis Cluster.

    TlsEnabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    UpdatedAt string

    The date and time of the last update of the Redis Cluster.

    UserName string

    Identifier for the first user of the Redis Cluster.

    Version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    acls List<RedisClusterAcl>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    certificate String

    The PEM of the certificate used by redis, only when tls_enabled is true

    clusterSize Integer

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    createdAt String

    The date and time of creation of the Redis Cluster.

    name String

    The name of the Redis Cluster.

    nodeType String

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password String

    Password for the first user of the Redis Cluster.

    privateNetworks List<RedisClusterPrivateNetwork>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId String

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Map<String,String>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags List<String>

    The tags associated with the Redis Cluster.

    tlsEnabled Boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    updatedAt String

    The date and time of the last update of the Redis Cluster.

    userName String

    Identifier for the first user of the Redis Cluster.

    version String

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    acls RedisClusterAcl[]

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    certificate string

    The PEM of the certificate used by redis, only when tls_enabled is true

    clusterSize number

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    createdAt string

    The date and time of creation of the Redis Cluster.

    name string

    The name of the Redis Cluster.

    nodeType string

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password string

    Password for the first user of the Redis Cluster.

    privateNetworks RedisClusterPrivateNetwork[]

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId string

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork RedisClusterPublicNetwork

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings {[key: string]: string}

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags string[]

    The tags associated with the Redis Cluster.

    tlsEnabled boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    updatedAt string

    The date and time of the last update of the Redis Cluster.

    userName string

    Identifier for the first user of the Redis Cluster.

    version string

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    zone string

    zone) The zone in which the Redis Cluster should be created.

    acls Sequence[RedisClusterAclArgs]

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    certificate str

    The PEM of the certificate used by redis, only when tls_enabled is true

    cluster_size int

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    created_at str

    The date and time of creation of the Redis Cluster.

    name str

    The name of the Redis Cluster.

    node_type str

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password str

    Password for the first user of the Redis Cluster.

    private_networks Sequence[RedisClusterPrivateNetworkArgs]

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    project_id str

    project_id) The ID of the project the Redis Cluster is associated with.

    public_network RedisClusterPublicNetworkArgs

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Mapping[str, str]

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags Sequence[str]

    The tags associated with the Redis Cluster.

    tls_enabled bool

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    updated_at str

    The date and time of the last update of the Redis Cluster.

    user_name str

    Identifier for the first user of the Redis Cluster.

    version str

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    zone str

    zone) The zone in which the Redis Cluster should be created.

    acls List<Property Map>

    List of acl rules, this is cluster's authorized IPs. More details on the ACL section.

    certificate String

    The PEM of the certificate used by redis, only when tls_enabled is true

    clusterSize Number

    The number of nodes in the Redis Cluster.

    Important: You cannot set cluster_size to 2, you either have to choose Standalone mode (1 node) or Cluster mode which is minimum 3 (1 main node + 2 secondary nodes)

    Important: You can set a bigger cluster_size than you initially did, it will migrate the Redis Cluster, but keep in mind that you cannot downgrade a Redis Cluster so setting a smaller cluster_size will not have any effect.

    createdAt String

    The date and time of creation of the Redis Cluster.

    name String

    The name of the Redis Cluster.

    nodeType String

    The type of Redis Cluster you want to create (e.g. RED1-M).

    Important: Updates to node_type will migrate the Redis Cluster to the desired node_type. Keep in mind that you cannot downgrade a Redis Cluster.

    password String

    Password for the first user of the Redis Cluster.

    privateNetworks List<Property Map>

    Describes the private network you want to connect to your cluster. If not set, a public network will be provided. More details on the Private Network section

    Important: The way to use private networks differs whether you are using redis in standalone or cluster mode.

    • Standalone mode (cluster_size = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.

    • Cluster mode (cluster_size > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterward, unless you create another cluster. Your service_ips must be listed as follows:

    import * as pulumi from "@pulumi/pulumi";
    
    import pulumi
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    

    return await Deployment.RunAsync(() => { });

    package main
    
    import (
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		return nil
    	})
    }
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    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) {
        }
    }
    
    {}
    
    projectId String

    project_id) The ID of the project the Redis Cluster is associated with.

    publicNetwork Property Map

    (Optional) Public network details. Only one of private_network and public_network may be set.

    The public_network block exports:

    settings Map<String>

    Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI

    tags List<String>

    The tags associated with the Redis Cluster.

    tlsEnabled Boolean

    Whether TLS is enabled or not.

    The changes on tls_enabled will force the resource creation.

    updatedAt String

    The date and time of the last update of the Redis Cluster.

    userName String

    Identifier for the first user of the Redis Cluster.

    version String

    Redis's Cluster version (e.g. 6.2.6).

    Important: Updates to version will migrate the Redis Cluster to the desired version. Keep in mind that you cannot downgrade a Redis Cluster.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    Supporting Types

    RedisClusterAcl, RedisClusterAclArgs

    Ip string

    The ip range to whitelist in CIDR notation

    Description string

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    Id string

    The UUID of the private network resource.

    Ip string

    The ip range to whitelist in CIDR notation

    Description string

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    Id string

    The UUID of the private network resource.

    ip String

    The ip range to whitelist in CIDR notation

    description String

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    id String

    The UUID of the private network resource.

    ip string

    The ip range to whitelist in CIDR notation

    description string

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    id string

    The UUID of the private network resource.

    ip str

    The ip range to whitelist in CIDR notation

    description str

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    id str

    The UUID of the private network resource.

    ip String

    The ip range to whitelist in CIDR notation

    description String

    A text describing this rule. Default description: Allow IP

    The acl conflict with private_network. Only one should be specified.

    id String

    The UUID of the private network resource.

    RedisClusterPrivateNetwork, RedisClusterPrivateNetworkArgs

    Id string

    The UUID of the private network resource.

    EndpointId string
    ServiceIps List<string>

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    Id string

    The UUID of the private network resource.

    EndpointId string
    ServiceIps []string

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    Zone string

    zone) The zone in which the Redis Cluster should be created.

    id String

    The UUID of the private network resource.

    endpointId String
    serviceIps List<String>

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    id string

    The UUID of the private network resource.

    endpointId string
    serviceIps string[]

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    zone string

    zone) The zone in which the Redis Cluster should be created.

    id str

    The UUID of the private network resource.

    endpoint_id str
    service_ips Sequence[str]

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    zone str

    zone) The zone in which the Redis Cluster should be created.

    id String

    The UUID of the private network resource.

    endpointId String
    serviceIps List<String>

    Endpoint IPv4 addresses in CIDR notation. You must provide at least one IP per node or The IP network address within the private subnet is determined by the IP Address Management (IPAM) service if not set.

    The private_network conflict with acl. Only one should be specified.

    zone String

    zone) The zone in which the Redis Cluster should be created.

    RedisClusterPublicNetwork, RedisClusterPublicNetworkArgs

    Id string

    The UUID of the private network resource.

    Ips List<string>

    Lis of IPv4 address of the endpoint (IP address).

    Port int

    TCP port of the endpoint.

    Id string

    The UUID of the private network resource.

    Ips []string

    Lis of IPv4 address of the endpoint (IP address).

    Port int

    TCP port of the endpoint.

    id String

    The UUID of the private network resource.

    ips List<String>

    Lis of IPv4 address of the endpoint (IP address).

    port Integer

    TCP port of the endpoint.

    id string

    The UUID of the private network resource.

    ips string[]

    Lis of IPv4 address of the endpoint (IP address).

    port number

    TCP port of the endpoint.

    id str

    The UUID of the private network resource.

    ips Sequence[str]

    Lis of IPv4 address of the endpoint (IP address).

    port int

    TCP port of the endpoint.

    id String

    The UUID of the private network resource.

    ips List<String>

    Lis of IPv4 address of the endpoint (IP address).

    port Number

    TCP port of the endpoint.

    Import

    Redis Cluster can be imported using the {zone}/{id}, e.g. bash

     $ pulumi import scaleway:index/redisCluster:RedisCluster main fr-par-1/11111111-1111-1111-1111-111111111111
    

    Package Details

    Repository
    scaleway lbrlabs/pulumi-scaleway
    License
    Apache-2.0
    Notes

    This Pulumi package is based on the scaleway Terraform Provider.

    scaleway logo
    Scaleway v1.10.0 published on Saturday, Jul 1, 2023 by lbrlabs