java.lang.Object
- com.pulumi.resources.Resource
- - com.pulumi.resources.CustomResource
  - - com.pulumi.aws.dynamodb.Table

public class Table
extends com.pulumi.resources.CustomResource

Provides a DynamoDB table resource. > **Note:** We recommend using `lifecycle` `ignoreChanges` for `readCapacity` and/or `writeCapacity` if there's Auto Scaling policy attached to the table. > **Note:** When using aws.dynamodb.TableReplica with this resource, use `lifecycle` `ignoreChanges` for `replica`, _e.g._, `lifecycle { ignoreChanges = [replica] }`. > **Note:** If Auto Scaling creates drift for your `globalSecondaryIndex` blocks and/or more granular `lifecycle` management for GSIs, we recommend using the new **experimental** resource `aws.dynamodb.GlobalSecondaryIndex`. > **Note:** Only define attributes on the table object that are going to be used as a hash key or range key for the table itself, or for LSI/GSI keys. Adding attributes not used in these scenarios causes an infinite plan loop. When using `aws.dynamodb.GlobalSecondaryIndex`, you do not need to define attributes for externally managed GSIs in the `aws.dynamodb.Table` resource. ## Example Usage ### Basic Example The following DynamoDB table description models the table and GSI shown in the [AWS SDK example documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html)

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableTtlArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableGlobalSecondaryIndexArgs;
 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 basic_dynamodb_table = new Table("basic-dynamodb-table", TableArgs.builder()
             .ttl(TableTtlArgs.builder()
                 .attributeName("TimeToExist")
                 .enabled(true)
                 .build())
             .attributes(            
                 TableAttributeArgs.builder()
                     .name("UserId")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("GameTitle")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("TopScore")
                     .type("N")
                     .build())
             .globalSecondaryIndexes(TableGlobalSecondaryIndexArgs.builder()
                 .name("GameTitleIndex")
                 .hashKey("GameTitle")
                 .rangeKey("TopScore")
                 .writeCapacity(10)
                 .readCapacity(10)
                 .projectionType("INCLUDE")
                 .nonKeyAttributes("UserId")
                 .build())
             .name("GameScores")
             .billingMode("PROVISIONED")
             .readCapacity(20)
             .writeCapacity(20)
             .hashKey("UserId")
             .rangeKey("GameTitle")
             .tags(Map.ofEntries(
                 Map.entry("Name", "dynamodb-table-1"),
                 Map.entry("Environment", "production")
             ))
             .build());
 
     }
 }

### Basic Example containing Global Secondary Indexes using Multi-attribute keys pattern The following DynamoDB table description models the table and GSIs shown in the [AWS SDK example documentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.DesignPattern.MultiAttributeKeys.html) > **Note:** Multi-attribute keys for GSIs use the `keySchema` block instead of `hashKey`/`rangeKey`. The `hashKey` and `rangeKey` arguments are deprecated in favor of `keySchema`.

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableTtlArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableGlobalSecondaryIndexArgs;
 import com.pulumi.aws.dynamodb.inputs.TableGlobalSecondaryIndexKeySchemaArgs;
 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 basic_dynamodb_table = new Table("basic-dynamodb-table", TableArgs.builder()
             .ttl(TableTtlArgs.builder()
                 .attributeName("TimeToExist")
                 .enabled(true)
                 .build())
             .attributes(            
                 TableAttributeArgs.builder()
                     .name("matchId")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("tournamentId")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("region")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("round")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("bracket")
                     .type("S")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("playerId")
                     .type("N")
                     .build(),
                 TableAttributeArgs.builder()
                     .name("matchDate")
                     .type("S")
                     .build())
             .globalSecondaryIndexes(            
                 TableGlobalSecondaryIndexArgs.builder()
                     .keySchemas(                    
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("tournamentId")
                             .keyType("HASH")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("region")
                             .keyType("HASH")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("round")
                             .keyType("RANGE")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("bracket")
                             .keyType("RANGE")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("matchId")
                             .keyType("RANGE")
                             .build())
                     .name("TournamentRegionIndex")
                     .writeCapacity(10)
                     .readCapacity(10)
                     .projectionType("ALL")
                     .build(),
                 TableGlobalSecondaryIndexArgs.builder()
                     .keySchemas(                    
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("playerId")
                             .keyType("HASH")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("matchDate")
                             .keyType("RANGE")
                             .build(),
                         TableGlobalSecondaryIndexKeySchemaArgs.builder()
                             .attributeName("round")
                             .keyType("RANGE")
                             .build())
                     .name("PlayerMatchHistoryIndex")
                     .writeCapacity(10)
                     .readCapacity(10)
                     .projectionType("ALL")
                     .build())
             .name("TournamentMatches")
             .billingMode("PROVISIONED")
             .readCapacity(20)
             .writeCapacity(20)
             .hashKey("matchId")
             .tags(Map.ofEntries(
                 Map.entry("Name", "dynamodb-table-1"),
                 Map.entry("Environment", "production")
             ))
             .build());
 
     }
 }

### Global Tables This resource implements support for [DynamoDB Global Tables V2 (version 2019.11.21)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html) via `replica` configuration blocks. For working with [DynamoDB Global Tables V1 (version 2017.11.29)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html), see the `aws.dynamodb.GlobalTable` resource. > **Note:** aws.dynamodb.TableReplica is an alternate way of configuring Global Tables. Do not use `replica` configuration blocks of `aws.dynamodb.Table` together with aws_dynamodb_table_replica.

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableReplicaArgs;
 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 Table("example", TableArgs.builder()
             .attributes(TableAttributeArgs.builder()
                 .name("TestTableHashKey")
                 .type("S")
                 .build())
             .replicas(            
                 TableReplicaArgs.builder()
                     .regionName("us-east-2")
                     .build(),
                 TableReplicaArgs.builder()
                     .regionName("us-west-2")
                     .build())
             .name("example")
             .hashKey("TestTableHashKey")
             .billingMode("PAY_PER_REQUEST")
             .streamEnabled(true)
             .streamViewType("NEW_AND_OLD_IMAGES")
             .build());
 
     }
 }

#### Global Tables with Multi-Region Strong Consistency A global table configured for Multi-Region strong consistency (MRSC) provides the ability to perform a strongly consistent read with multi-Region scope. Performing a strongly consistent read on an MRSC table ensures you're always reading the latest version of an item, irrespective of the Region in which you're performing the read. You can configure a MRSC global table with three replicas, or with two replicas and one witness. A witness is a component of a MRSC global table that contains data written to global table replicas, and provides an optional alternative to a full replica while supporting MRSC's availability architecture. You cannot perform read or write operations on a witness. A witness is located in a different Region than the two replicas. **Note** Please see detailed information, restrictions, caveats etc on the [AWS Support Page](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/multi-region-strong-consistency-gt.html). Consistency Mode (`consistencyMode`) on the embedded `replica` allows you to configure consistency mode for Global Tables. ### Consistency mode with 3 Replicas

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableReplicaArgs;
 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 Table("example", TableArgs.builder()
             .attributes(TableAttributeArgs.builder()
                 .name("TestTableHashKey")
                 .type("S")
                 .build())
             .replicas(            
                 TableReplicaArgs.builder()
                     .regionName("us-east-2")
                     .consistencyMode("STRONG")
                     .build(),
                 TableReplicaArgs.builder()
                     .regionName("us-west-2")
                     .consistencyMode("STRONG")
                     .build())
             .name("example")
             .hashKey("TestTableHashKey")
             .billingMode("PAY_PER_REQUEST")
             .streamEnabled(true)
             .streamViewType("NEW_AND_OLD_IMAGES")
             .build());
 
     }
 }

### Consistency Mode with 2 Replicas and Witness Region

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableGlobalTableWitnessArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableReplicaArgs;
 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 Table("example", TableArgs.builder()
             .globalTableWitness(TableGlobalTableWitnessArgs.builder()
                 .regionName("us-west-2")
                 .build())
             .attributes(TableAttributeArgs.builder()
                 .name("TestTableHashKey")
                 .type("S")
                 .build())
             .replicas(TableReplicaArgs.builder()
                 .regionName("us-east-2")
                 .consistencyMode("STRONG")
                 .build())
             .name("example")
             .hashKey("TestTableHashKey")
             .billingMode("PAY_PER_REQUEST")
             .streamEnabled(true)
             .streamViewType("NEW_AND_OLD_IMAGES")
             .build());
 
     }
 }

### Replica Tagging You can manage global table replicas' tags in various ways. This example shows using `replica.*.propagate_tags` for the first replica and the `aws.dynamodb.Tag` resource for the other.

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.AwsFunctions;
 import com.pulumi.aws.inputs.GetRegionArgs;
 import com.pulumi.aws.dynamodb.Table;
 import com.pulumi.aws.dynamodb.TableArgs;
 import com.pulumi.aws.dynamodb.inputs.TableAttributeArgs;
 import com.pulumi.aws.dynamodb.inputs.TableReplicaArgs;
 import com.pulumi.aws.dynamodb.Tag;
 import com.pulumi.aws.dynamodb.TagArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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) {
         final var current = AwsFunctions.getRegion(GetRegionArgs.builder()
             .build());
 
         final var alternate = AwsFunctions.getRegion(GetRegionArgs.builder()
             .build());
 
         final var third = AwsFunctions.getRegion(GetRegionArgs.builder()
             .build());
 
         var example = new Table("example", TableArgs.builder()
             .attributes(TableAttributeArgs.builder()
                 .name("TestTableHashKey")
                 .type("S")
                 .build())
             .replicas(            
                 TableReplicaArgs.builder()
                     .regionName(alternate.region())
                     .build(),
                 TableReplicaArgs.builder()
                     .regionName(third.region())
                     .propagateTags(true)
                     .build())
             .billingMode("PAY_PER_REQUEST")
             .hashKey("TestTableHashKey")
             .name("example-13281")
             .streamEnabled(true)
             .streamViewType("NEW_AND_OLD_IMAGES")
             .tags(Map.ofEntries(
                 Map.entry("Architect", "Eleanor"),
                 Map.entry("Zone", "SW")
             ))
             .build());
 
         var exampleTag = new Tag("exampleTag", TagArgs.builder()
             .resourceArn(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.arn())
                 .search(current.region())
                 .replace(alternate.region())
                 .build()).applyValue(_invoke -> _invoke.result()))
             .key("Architect")
             .value("Gigi")
             .build());
 
     }
 }

## Import ### Identity Schema #### Required * `name` (String) Name of the DynamoDB Table. #### Optional * `accountId` (String) AWS Account where this resource is managed. * `region` (String) Region where this resource is managed. Using `pulumi import`, import DynamoDB tables using the `name`. For example: ```sh $ pulumi import aws:dynamodb/table:Table basic-dynamodb-table GameScores ```

Nested Class Summary
- Nested classes/interfaces inherited from class com.pulumi.resources.CustomResource
  com.pulumi.resources.CustomResource.CustomResourceInternal
- Nested classes/interfaces inherited from class com.pulumi.resources.Resource
  com.pulumi.resources.Resource.LazyField<T extends java.lang.Object>, com.pulumi.resources.Resource.LazyFields, com.pulumi.resources.Resource.ResourceInternal

Field Summary
- Fields inherited from class com.pulumi.resources.Resource
  childResources, remote

Constructor Summary

Constructors
Constructor	Description
`Table(java.lang.String name)`
`Table(java.lang.String name, TableArgs args)`
`Table(java.lang.String name, TableArgs args, com.pulumi.resources.CustomResourceOptions options)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`com.pulumi.core.Output<java.lang.String>`	`arn()`
`com.pulumi.core.Output<java.util.List<TableAttribute>>`	`attributes()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`billingMode()`
`com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>>`	`deletionProtectionEnabled()`
`static Table`	`get(java.lang.String name, com.pulumi.core.Output<java.lang.String> id, TableState state, com.pulumi.resources.CustomResourceOptions options)`	Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
`com.pulumi.core.Output<java.util.List<TableGlobalSecondaryIndex>>`	`globalSecondaryIndexes()`
`com.pulumi.core.Output<TableGlobalTableWitness>`	`globalTableWitness()`
`com.pulumi.core.Output<java.lang.String>`	`hashKey()`
`com.pulumi.core.Output<java.util.Optional<TableImportTable>>`	`importTable()`
`com.pulumi.core.Output<java.util.Optional<java.util.List<TableLocalSecondaryIndex>>>`	`localSecondaryIndexes()`
`com.pulumi.core.Output<java.lang.String>`	`name()`
`com.pulumi.core.Output<java.util.Optional<TableOnDemandThroughput>>`	`onDemandThroughput()`
`com.pulumi.core.Output<TablePointInTimeRecovery>`	`pointInTimeRecovery()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`rangeKey()`
`com.pulumi.core.Output<java.lang.Integer>`	`readCapacity()`
`com.pulumi.core.Output<java.lang.String>`	`region()`
`com.pulumi.core.Output<java.util.Optional<java.util.List<TableReplica>>>`	`replicas()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`restoreBackupArn()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`restoreDateTime()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`restoreSourceName()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`restoreSourceTableArn()`
`com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>>`	`restoreToLatestTime()`
`com.pulumi.core.Output<TableServerSideEncryption>`	`serverSideEncryption()`
`com.pulumi.core.Output<java.lang.String>`	`streamArn()`
`com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>>`	`streamEnabled()`
`com.pulumi.core.Output<java.lang.String>`	`streamLabel()`
`com.pulumi.core.Output<java.lang.String>`	`streamViewType()`
`com.pulumi.core.Output<java.util.Optional<java.lang.String>>`	`tableClass()`
`com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,java.lang.String>>>`	`tags()`
`com.pulumi.core.Output<java.util.Map<java.lang.String,java.lang.String>>`	`tagsAll()`
`com.pulumi.core.Output<TableTtl>`	`ttl()`
`com.pulumi.core.Output<TableWarmThroughput>`	`warmThroughput()`
`com.pulumi.core.Output<java.lang.Integer>`	`writeCapacity()`

Methods inherited from class com.pulumi.resources.CustomResource
getId, id, idFuture

Methods inherited from class com.pulumi.resources.Resource
getChildResources, getResourceName, getResourceType, getUrn, pulumiChildResources, pulumiResourceName, pulumiResourceType, urn

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Table
```
public Table(java.lang.String name)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
  - Table
```
public Table(java.lang.String name,
             @Nullable
             TableArgs args)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    args - The arguments to use to populate this resource's properties.
  - Table
```
public Table(java.lang.String name,
             @Nullable
             TableArgs args,
             @Nullable
             com.pulumi.resources.CustomResourceOptions options)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    args - The arguments to use to populate this resource's properties.
    
    options - A bag of options that control this resource's behavior.
- Method Detail
  - arn
```
public com.pulumi.core.Output<java.lang.String> arn()
```
    Returns:
    
    ARN of the table * `replica.*.arn` - ARN of the replica * `replica.*.stream_arn` - ARN of the replica Table Stream. Only available when `streamEnabled = true`. * `replica.*.stream_label` - Timestamp, in ISO 8601 format, for the replica stream. Note that this timestamp is not a unique identifier for the stream on its own. However, the combination of AWS customer ID, table name and this field is guaranteed to be unique. It can be used for creating CloudWatch Alarms. Only available when `streamEnabled = true`.
  - attributes
```
public com.pulumi.core.Output<java.util.List<TableAttribute>> attributes()
```
    Returns:
    
    Set of nested attribute definitions. Only required for `hashKey` and `rangeKey` attributes. See below.
  - billingMode
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> billingMode()
```
    Returns:
    
    Controls how you are charged for read and write throughput and how you manage capacity. The valid values are `PROVISIONED` and `PAY_PER_REQUEST`. Defaults to `PROVISIONED`.
  - deletionProtectionEnabled
```
public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> deletionProtectionEnabled()
```
    Returns:
    
    Enables deletion protection for table. Defaults to `false`.
  - globalSecondaryIndexes
```
public com.pulumi.core.Output<java.util.List<TableGlobalSecondaryIndex>> globalSecondaryIndexes()
```
    Returns:
    
    Describe a GSI for the table; subject to the normal limits on the number of GSIs, projected attributes, etc. See below.
  - globalTableWitness
```
public com.pulumi.core.Output<TableGlobalTableWitness> globalTableWitness()
```
    Returns:
    
    Witness Region in a Multi-Region Strong Consistency deployment. **Note** This must be used alongside a single `replica` with `consistencyMode` set to `STRONG`. Other combinations will fail to provision. See below.
  - hashKey
```
public com.pulumi.core.Output<java.lang.String> hashKey()
```
    Returns:
    
    Attribute to use as the hash (partition) key. Must also be defined as an `attribute`. See below.
  - importTable
```
public com.pulumi.core.Output<java.util.Optional<TableImportTable>> importTable()
```
    Returns:
    
    Import Amazon S3 data into a new table. See below.
  - localSecondaryIndexes
```
public com.pulumi.core.Output<java.util.Optional<java.util.List<TableLocalSecondaryIndex>>> localSecondaryIndexes()
```
    Returns:
    
    Describe an LSI on the table; these can only be allocated _at creation_ so you cannot change this definition after you have created the resource. See below.
  - name
```
public com.pulumi.core.Output<java.lang.String> name()
```
    Returns:
    
    Unique within a region name of the table. The following arguments are optional:
  - onDemandThroughput
```
public com.pulumi.core.Output<java.util.Optional<TableOnDemandThroughput>> onDemandThroughput()
```
    Returns:
    
    Sets the maximum number of read and write units for the specified on-demand table. See below.
  - pointInTimeRecovery
```
public com.pulumi.core.Output<TablePointInTimeRecovery> pointInTimeRecovery()
```
    Returns:
    
    Enable point-in-time recovery options. See below.
  - rangeKey
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> rangeKey()
```
    Returns:
    
    Attribute to use as the range (sort) key. Must also be defined as an `attribute`, see below.
  - readCapacity
```
public com.pulumi.core.Output<java.lang.Integer> readCapacity()
```
    Returns:
    
    Number of read units for this table. If the `billingMode` is `PROVISIONED`, this field is required.
  - region
```
public com.pulumi.core.Output<java.lang.String> region()
```
    Returns:
    
    Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
  - replicas
```
public com.pulumi.core.Output<java.util.Optional<java.util.List<TableReplica>>> replicas()
```
    Returns:
    
    Configuration block(s) with [DynamoDB Global Tables V2 (version 2019.11.21)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html) replication configurations. See below.
  - restoreBackupArn
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> restoreBackupArn()
```
    Returns:
    
    ARN of backup to restore.
  - restoreDateTime
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> restoreDateTime()
```
    Returns:
    
    Time of the point-in-time recovery point to restore.
  - restoreSourceName
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> restoreSourceName()
```
    Returns:
    
    Name of the table to restore. Must match the name of an existing table.
  - restoreSourceTableArn
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> restoreSourceTableArn()
```
    Returns:
    
    ARN of the source table to restore. Must be supplied for cross-region restores.
  - restoreToLatestTime
```
public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> restoreToLatestTime()
```
    Returns:
    
    If set, restores table to the most recent point-in-time recovery point.
  - serverSideEncryption
```
public com.pulumi.core.Output<TableServerSideEncryption> serverSideEncryption()
```
    Returns:
    
    Encryption at rest options. AWS DynamoDB tables are automatically encrypted at rest with an AWS-owned Customer Master Key if this argument isn't specified. Must be supplied for cross-region restores. See below.
  - streamArn
```
public com.pulumi.core.Output<java.lang.String> streamArn()
```
    Returns:
    
    ARN of the Table Stream. Only available when `streamEnabled = true`
  - streamEnabled
```
public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> streamEnabled()
```
    Returns:
    
    Whether Streams are enabled.
  - streamLabel
```
public com.pulumi.core.Output<java.lang.String> streamLabel()
```
    Returns:
    
    Timestamp, in ISO 8601 format, for this stream. Note that this timestamp is not a unique identifier for the stream on its own. However, the combination of AWS customer ID, table name and this field is guaranteed to be unique. It can be used for creating CloudWatch Alarms. Only available when `streamEnabled = true`.
  - streamViewType
```
public com.pulumi.core.Output<java.lang.String> streamViewType()
```
    Returns:
    
    When an item in the table is modified, StreamViewType determines what information is written to the table's stream. Valid values are `KEYS_ONLY`, `NEW_IMAGE`, `OLD_IMAGE`, `NEW_AND_OLD_IMAGES`. Only valid when `streamEnabled` is true.
  - tableClass
```
public com.pulumi.core.Output<java.util.Optional<java.lang.String>> tableClass()
```
    Returns:
    
    Storage class of the table. Valid values are `STANDARD` and `STANDARD_INFREQUENT_ACCESS`. Default value is `STANDARD`.
  - tags
```
public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,java.lang.String>>> tags()
```
    Returns:
    
    A map of tags to populate on the created table. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
  - tagsAll
```
public com.pulumi.core.Output<java.util.Map<java.lang.String,java.lang.String>> tagsAll()
```
    Returns:
    
    Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
  - ttl
```
public com.pulumi.core.Output<TableTtl> ttl()
```
    Returns:
    
    Configuration block for TTL. See below.
  - warmThroughput
```
public com.pulumi.core.Output<TableWarmThroughput> warmThroughput()
```
    Returns:
    
    Sets the number of warm read and write units for the specified table. See below.
  - writeCapacity
```
public com.pulumi.core.Output<java.lang.Integer> writeCapacity()
```
    Returns:
    
    Number of write units for this table. If the `billingMode` is `PROVISIONED`, this field is required.
  - get
```
public static Table get(java.lang.String name,
                        com.pulumi.core.Output<java.lang.String> id,
                        @Nullable
                        TableState state,
                        @Nullable
                        com.pulumi.resources.CustomResourceOptions options)
```
    Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
    
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    id - The _unique_ provider ID of the resource to lookup.
    
    state -
    
    options - Optional settings to control the behavior of the CustomResource.

Class Table

Nested Class Summary

Nested classes/interfaces inherited from class com.pulumi.resources.CustomResource

Nested classes/interfaces inherited from class com.pulumi.resources.Resource

Field Summary

Fields inherited from class com.pulumi.resources.Resource

Constructor Summary

Method Summary

Methods inherited from class com.pulumi.resources.CustomResource

Methods inherited from class com.pulumi.resources.Resource

Methods inherited from class java.lang.Object

Constructor Detail

Table

Table

Table

Method Detail

arn

attributes

billingMode

deletionProtectionEnabled

globalSecondaryIndexes

globalTableWitness

hashKey

importTable

localSecondaryIndexes

name

onDemandThroughput

pointInTimeRecovery

rangeKey

readCapacity

region

replicas

restoreBackupArn

restoreDateTime

restoreSourceName

restoreSourceTableArn

restoreToLatestTime

serverSideEncryption

streamArn

streamEnabled

streamLabel

streamViewType

tableClass

tags

tagsAll

ttl

warmThroughput

writeCapacity

get