ServerlessCache class

Provides an ElastiCache Serverless Cache resource which manages memcached, redis or valkey.

Example Usage

Memcached Serverless

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

const example = new aws.elasticache.ServerlessCache("example", {
    cacheUsageLimits: {
        dataStorage: {
            maximum: 10,
            unit: "GB",
        },
        ecpuPerSeconds: [{
            maximum: 5000,
        }],
    },
    engine: "memcached",
    name: "example",
    description: "Test Server",
    kmsKeyId: test.arn,
    majorEngineVersion: "1.6",
    securityGroupIds: [testAwsSecurityGroup.id],
    subnetIds: testAwsSubnet.map(__item => __item.id),
});
import pulumi
import pulumi_aws as aws

example = aws.elasticache.ServerlessCache("example",
    cache_usage_limits={
        "data_storage": {
            "maximum": 10,
            "unit": "GB",
        },
        "ecpu_per_seconds": [{
            "maximum": 5000,
        }],
    },
    engine="memcached",
    name="example",
    description="Test Server",
    kms_key_id=test["arn"],
    major_engine_version="1.6",
    security_group_ids=[test_aws_security_group["id"]],
    subnet_ids=[__item["id"] for __item in test_aws_subnet])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ElastiCache.ServerlessCache("example", new()
    {
        CacheUsageLimits = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsArgs
        {
            DataStorage = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs
            {
                Maximum = 10,
                Unit = "GB",
            },
            EcpuPerSeconds = new[]
            {
                new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs
                {
                    Maximum = 5000,
                },
            },
        },
        Engine = "memcached",
        Name = "example",
        Description = "Test Server",
        KmsKeyId = test.Arn,
        MajorEngineVersion = "1.6",
        SecurityGroupIds = new[]
        {
            testAwsSecurityGroup.Id,
        },
        SubnetIds = testAwsSubnet.Select(__item => __item.Id).ToList(),
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range testAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["id"])
}
_, err := elasticache.NewServerlessCache(ctx, "example", &elasticache.ServerlessCacheArgs{
CacheUsageLimits: &elasticache.ServerlessCacheCacheUsageLimitsArgs{
DataStorage: &elasticache.ServerlessCacheCacheUsageLimitsDataStorageArgs{
Maximum: pulumi.Int(10),
Unit: pulumi.String("GB"),
},
EcpuPerSeconds: elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArray{
&elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs{
Maximum: pulumi.Int(5000),
},
},
},
Engine: pulumi.String("memcached"),
Name: pulumi.String("example"),
Description: pulumi.String("Test Server"),
KmsKeyId: pulumi.Any(test.Arn),
MajorEngineVersion: pulumi.String("1.6"),
SecurityGroupIds: pulumi.StringArray{
testAwsSecurityGroup.Id,
},
SubnetIds: toPulumiArray(splat0),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_elasticache_serverlesscache" "example" {
  cache_usage_limits = {
    data_storage = {
      maximum = 10
      unit    = "GB"
    }
    ecpu_per_seconds = [{
      "maximum" = 5000
    }]
  }
  engine               = "memcached"
  name                 = "example"
  description          = "Test Server"
  kms_key_id           = test.arn
  major_engine_version = "1.6"
  security_group_ids   = [testAwsSecurityGroup.id]
  subnet_ids           = testAwsSubnet[*].id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.elasticache.ServerlessCache;
import com.pulumi.aws.elasticache.ServerlessCacheArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new ServerlessCache("example", ServerlessCacheArgs.builder()
            .cacheUsageLimits(ServerlessCacheCacheUsageLimitsArgs.builder()
                .dataStorage(ServerlessCacheCacheUsageLimitsDataStorageArgs.builder()
                    .maximum(10)
                    .unit("GB")
                    .build())
                .ecpuPerSeconds(ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs.builder()
                    .maximum(5000)
                    .build())
                .build())
            .engine("memcached")
            .name("example")
            .description("Test Server")
            .kmsKeyId(test.arn())
            .majorEngineVersion("1.6")
            .securityGroupIds(testAwsSecurityGroup.id())
            .subnetIds(testAwsSubnet.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

Redis OSS Serverless

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

const example = new aws.elasticache.ServerlessCache("example", {
    cacheUsageLimits: {
        dataStorage: {
            maximum: 10,
            unit: "GB",
        },
        ecpuPerSeconds: [{
            maximum: 5000,
        }],
    },
    engine: "redis",
    name: "example",
    dailySnapshotTime: "09:00",
    description: "Test Server",
    kmsKeyId: test.arn,
    majorEngineVersion: "7",
    snapshotRetentionLimit: 1,
    securityGroupIds: [testAwsSecurityGroup.id],
    subnetIds: testAwsSubnet.map(__item => __item.id),
});
import pulumi
import pulumi_aws as aws

example = aws.elasticache.ServerlessCache("example",
    cache_usage_limits={
        "data_storage": {
            "maximum": 10,
            "unit": "GB",
        },
        "ecpu_per_seconds": [{
            "maximum": 5000,
        }],
    },
    engine="redis",
    name="example",
    daily_snapshot_time="09:00",
    description="Test Server",
    kms_key_id=test["arn"],
    major_engine_version="7",
    snapshot_retention_limit=1,
    security_group_ids=[test_aws_security_group["id"]],
    subnet_ids=[__item["id"] for __item in test_aws_subnet])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ElastiCache.ServerlessCache("example", new()
    {
        CacheUsageLimits = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsArgs
        {
            DataStorage = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs
            {
                Maximum = 10,
                Unit = "GB",
            },
            EcpuPerSeconds = new[]
            {
                new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs
                {
                    Maximum = 5000,
                },
            },
        },
        Engine = "redis",
        Name = "example",
        DailySnapshotTime = "09:00",
        Description = "Test Server",
        KmsKeyId = test.Arn,
        MajorEngineVersion = "7",
        SnapshotRetentionLimit = 1,
        SecurityGroupIds = new[]
        {
            testAwsSecurityGroup.Id,
        },
        SubnetIds = testAwsSubnet.Select(__item => __item.Id).ToList(),
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range testAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["id"])
}
_, err := elasticache.NewServerlessCache(ctx, "example", &elasticache.ServerlessCacheArgs{
CacheUsageLimits: &elasticache.ServerlessCacheCacheUsageLimitsArgs{
DataStorage: &elasticache.ServerlessCacheCacheUsageLimitsDataStorageArgs{
Maximum: pulumi.Int(10),
Unit: pulumi.String("GB"),
},
EcpuPerSeconds: elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArray{
&elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs{
Maximum: pulumi.Int(5000),
},
},
},
Engine: pulumi.String("redis"),
Name: pulumi.String("example"),
DailySnapshotTime: pulumi.String("09:00"),
Description: pulumi.String("Test Server"),
KmsKeyId: pulumi.Any(test.Arn),
MajorEngineVersion: pulumi.String("7"),
SnapshotRetentionLimit: pulumi.Int(1),
SecurityGroupIds: pulumi.StringArray{
testAwsSecurityGroup.Id,
},
SubnetIds: toPulumiArray(splat0),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_elasticache_serverlesscache" "example" {
  cache_usage_limits = {
    data_storage = {
      maximum = 10
      unit    = "GB"
    }
    ecpu_per_seconds = [{
      "maximum" = 5000
    }]
  }
  engine                   = "redis"
  name                     = "example"
  daily_snapshot_time      = "09:00"
  description              = "Test Server"
  kms_key_id               = test.arn
  major_engine_version     = "7"
  snapshot_retention_limit = 1
  security_group_ids       = [testAwsSecurityGroup.id]
  subnet_ids               = testAwsSubnet[*].id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.elasticache.ServerlessCache;
import com.pulumi.aws.elasticache.ServerlessCacheArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new ServerlessCache("example", ServerlessCacheArgs.builder()
            .cacheUsageLimits(ServerlessCacheCacheUsageLimitsArgs.builder()
                .dataStorage(ServerlessCacheCacheUsageLimitsDataStorageArgs.builder()
                    .maximum(10)
                    .unit("GB")
                    .build())
                .ecpuPerSeconds(ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs.builder()
                    .maximum(5000)
                    .build())
                .build())
            .engine("redis")
            .name("example")
            .dailySnapshotTime("09:00")
            .description("Test Server")
            .kmsKeyId(test.arn())
            .majorEngineVersion("7")
            .snapshotRetentionLimit(1)
            .securityGroupIds(testAwsSecurityGroup.id())
            .subnetIds(testAwsSubnet.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

Valkey Serverless

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

const example = new aws.elasticache.ServerlessCache("example", {
    cacheUsageLimits: {
        dataStorage: {
            maximum: 10,
            unit: "GB",
        },
        ecpuPerSeconds: [{
            maximum: 5000,
        }],
    },
    engine: "valkey",
    name: "example",
    dailySnapshotTime: "09:00",
    description: "Test Server",
    kmsKeyId: test.arn,
    majorEngineVersion: "7",
    snapshotRetentionLimit: 1,
    securityGroupIds: [testAwsSecurityGroup.id],
    subnetIds: testAwsSubnet.map(__item => __item.id),
});
import pulumi
import pulumi_aws as aws

example = aws.elasticache.ServerlessCache("example",
    cache_usage_limits={
        "data_storage": {
            "maximum": 10,
            "unit": "GB",
        },
        "ecpu_per_seconds": [{
            "maximum": 5000,
        }],
    },
    engine="valkey",
    name="example",
    daily_snapshot_time="09:00",
    description="Test Server",
    kms_key_id=test["arn"],
    major_engine_version="7",
    snapshot_retention_limit=1,
    security_group_ids=[test_aws_security_group["id"]],
    subnet_ids=[__item["id"] for __item in test_aws_subnet])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ElastiCache.ServerlessCache("example", new()
    {
        CacheUsageLimits = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsArgs
        {
            DataStorage = new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs
            {
                Maximum = 10,
                Unit = "GB",
            },
            EcpuPerSeconds = new[]
            {
                new Aws.ElastiCache.Inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs
                {
                    Maximum = 5000,
                },
            },
        },
        Engine = "valkey",
        Name = "example",
        DailySnapshotTime = "09:00",
        Description = "Test Server",
        KmsKeyId = test.Arn,
        MajorEngineVersion = "7",
        SnapshotRetentionLimit = 1,
        SecurityGroupIds = new[]
        {
            testAwsSecurityGroup.Id,
        },
        SubnetIds = testAwsSubnet.Select(__item => __item.Id).ToList(),
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range testAwsSubnet {
splat0 = append(splat0, val0.(map[string]interface{})["id"])
}
_, err := elasticache.NewServerlessCache(ctx, "example", &elasticache.ServerlessCacheArgs{
CacheUsageLimits: &elasticache.ServerlessCacheCacheUsageLimitsArgs{
DataStorage: &elasticache.ServerlessCacheCacheUsageLimitsDataStorageArgs{
Maximum: pulumi.Int(10),
Unit: pulumi.String("GB"),
},
EcpuPerSeconds: elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArray{
&elasticache.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs{
Maximum: pulumi.Int(5000),
},
},
},
Engine: pulumi.String("valkey"),
Name: pulumi.String("example"),
DailySnapshotTime: pulumi.String("09:00"),
Description: pulumi.String("Test Server"),
KmsKeyId: pulumi.Any(test.Arn),
MajorEngineVersion: pulumi.String("7"),
SnapshotRetentionLimit: pulumi.Int(1),
SecurityGroupIds: pulumi.StringArray{
testAwsSecurityGroup.Id,
},
SubnetIds: toPulumiArray(splat0),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_elasticache_serverlesscache" "example" {
  cache_usage_limits = {
    data_storage = {
      maximum = 10
      unit    = "GB"
    }
    ecpu_per_seconds = [{
      "maximum" = 5000
    }]
  }
  engine                   = "valkey"
  name                     = "example"
  daily_snapshot_time      = "09:00"
  description              = "Test Server"
  kms_key_id               = test.arn
  major_engine_version     = "7"
  snapshot_retention_limit = 1
  security_group_ids       = [testAwsSecurityGroup.id]
  subnet_ids               = testAwsSubnet[*].id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.elasticache.ServerlessCache;
import com.pulumi.aws.elasticache.ServerlessCacheArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsDataStorageArgs;
import com.pulumi.aws.elasticache.inputs.ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new ServerlessCache("example", ServerlessCacheArgs.builder()
            .cacheUsageLimits(ServerlessCacheCacheUsageLimitsArgs.builder()
                .dataStorage(ServerlessCacheCacheUsageLimitsDataStorageArgs.builder()
                    .maximum(10)
                    .unit("GB")
                    .build())
                .ecpuPerSeconds(ServerlessCacheCacheUsageLimitsEcpuPerSecondArgs.builder()
                    .maximum(5000)
                    .build())
                .build())
            .engine("valkey")
            .name("example")
            .dailySnapshotTime("09:00")
            .description("Test Server")
            .kmsKeyId(test.arn())
            .majorEngineVersion("7")
            .snapshotRetentionLimit(1)
            .securityGroupIds(testAwsSecurityGroup.id())
            .subnetIds(testAwsSubnet.stream().map(element -> element.id()).collect(toList()))
            .build());

    }
}

Import

Using pulumi import, import ElastiCache Serverless Cache using the name. For example:

$ pulumi import aws:elasticache/serverlessCache:ServerlessCache my_cluster my_cluster

Constructors

ServerlessCache(String name, {ServerlessCacheArgs? args, CustomResourceOptions? options})
Creates a new ServerlessCache. name The Pulumi resource name. args Arguments used to configure this ServerlessCache. The set of arguments for ServerlessCache. options Resource options controlling this resource's behavior.
ServerlessCache.reference(String urn)
Creates a typed reference to an existing ServerlessCache resource.

Properties

arn ↔ Output<String>
ARN of the serverless cache.
latefinal
cacheUsageLimits ↔ Output<ServerlessCacheCacheUsageLimits?>
Sets the cache usage limits for storage and ElastiCache Processing Units for the cache. See cacheUsageLimits Block for details.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
createTime ↔ Output<String>
Timestamp of when the serverless cache was created.
latefinal
dailySnapshotTime ↔ Output<String>
The daily time that snapshots will be created from the new serverless cache. Only supported for engine types "redis" or "valkey". Defaults to 0.
latefinal
description ↔ Output<String>
User-provided description for the serverless cache. The default is NULL.
latefinal
endpoints ↔ Output<List<ServerlessCacheEndpoint>>
Represents the information required for client programs to connect to a cache node. See endpoint Block for details.
latefinal
engine ↔ Output<String>
Name of the cache engine to be used for this cache cluster. Valid values are memcached, redis or valkey.
latefinal
fullEngineVersion ↔ Output<String>
The name and version number of the engine the serverless cache is compatible with.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
kmsKeyId ↔ Output<String?>
ARN of the customer managed key for encrypting the data at rest. If no KMS key is provided, a default service key is used.
latefinal
majorEngineVersion ↔ Output<String>
The version of the cache engine that will be used to create the serverless cache. See Describe Cache Engine Versions in the AWS Documentation for supported versions.
latefinal
name ↔ Output<String>
The Cluster name which serves as a unique identifier to the serverless cache
latefinal
networkType ↔ Output<String>
IP protocol version used by the serverless cache. Valid values are ipv4, ipv6, or dualStack. ipv6 is only supported with IPv6-only subnets. If not specified, defaults to ipv4, unless all provided subnets are IPv6-only, in which case it defaults to ipv6.
latefinal
readerEndpoints ↔ Output<List<ServerlessCacheReaderEndpoint>>
Represents the information required for client programs to connect to a cache node. See readerEndpoint Block for details.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
securityGroupIds ↔ Output<List<String>>
A list of the one or more VPC security groups to be associated with the serverless cache. The security group will authorize traffic access for the VPC end-point (private-link). If no other information is given this will be the VPC’s Default Security Group that is associated with the cluster VPC end-point.
latefinal
snapshotArnsToRestores ↔ Output<List<String>?>
The list of ARN(s) of the snapshot that the new serverless cache will be created from. Only supported for engine types "redis" or "valkey".
latefinal
snapshotRetentionLimit ↔ Output<int>
The number of snapshots that will be retained for the serverless cache that is being created. As new snapshots beyond this limit are added, the oldest snapshots will be deleted on a rolling basis. Only supported for engine types "redis" or "valkey".
latefinal
status ↔ Output<String>
The current status of the serverless cache. The allowed values are CREATING, AVAILABLE, DELETING, CREATE-FAILED and MODIFYING.
latefinal
subnetIds ↔ Output<List<String>>
A list of the identifiers of the subnets where the VPC endpoint for the serverless cache will be deployed. All the subnetIds must belong to the same VPC.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
latefinal
timeouts ↔ Output<ServerlessCacheTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
userGroupId ↔ Output<String?>
The identifier of the UserGroup to be associated with the serverless cache. Available for Redis and Valkey. Default is NULL.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ServerlessCacheState? state, CustomResourceOptions? options}) → ServerlessCache
Gets an existing ServerlessCache resource's state with the given name and id.