I found your unanswered question today, and kept looking until I found an answer. Probably too late for you but may help others.

aws dynamodb create-table --cli-input-json file://tabledefinition.json

This command expects a json object in the file in the format outlined by the following command:

aws dynamodb create-table --generate-cli-skeleton

This approach seems to work with many aws commands.

100k writes would probably take a few minutes if writing slowly. You do have the ability to use DynamoDB Import from S3 feature, however, your data would need to be in DDB-JSON format, meaning you would have to run a process to convert JSON to DDB-JSON. Then you would need to upload the file to S3 before importing.

My suggestion would be to use whatever compute you are familiar with, EC2, Lambda or local machine and just write the items using a loop. You can speed it up using BatchWriteItems where you can write 25 items in a batch.

Or if you use Python, you can use Boto3's batch_writer where you can pass it all the items in a JSON array and it will do the BatchWriteItems on your behalf, inlcuding handling retries.

I was also trying to achieve something similar but I didn't find any lib for that purpose, hence I took a few minutes to code it myself.

Provided with a json file structured the same way as in the documentation example:

{
    TableName : "Music",
    KeySchema: [
        {
            AttributeName: "Artist",
            KeyType: "HASH", 
        },
        {
            AttributeName: "SongTitle",
            KeyType: "RANGE" 
        }
    ],
    AttributeDefinitions: [
        {
            AttributeName: "Artist",
            AttributeType: "S"
        },
        {
            AttributeName: "SongTitle",
            AttributeType: "S"
        }
    ],
    ProvisionedThroughput: {       
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1
    }
} 

The code bellow works. Note that:

• The createTable method expects a json string, which you can obtain using something like Files.readString(Path.of("path/to/your/file.json"))
• if you do not use Lombok you have to create constructors/getters/setters yourself
• the @JsonProperty annotations are only necessary if the class field names are not an exact match to the json ones (in this case, the first letter is uppercase), explained here.

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.model.*;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@RequiredArgsConstructor
    public class CreateTable {
        private final AmazonDynamoDB amazonDynamoDB;
    
        public void createTable(String json) throws JsonProcessingException {
            Table table = readTable(json);
            amazonDynamoDB.createTable(getTableRequest(table));
        }
    
        private CreateTableRequest getTableRequest(Table table) {
            return new CreateTableRequest()
                    .withTableName(table.getTableName())
                    .withKeySchema(toKeySchemaElement(table.getKeySchema()))
                    .withAttributeDefinitions(toAttributeDefinition(table.getAttributeDefinitions()))
                    .withProvisionedThroughput(toProvisionedThroughput(table.getProvisionedThroughput()));
        }
    
        private Table readTable(String json) throws JsonProcessingException {
            return new ObjectMapper().readValue(json, Table.class);
        }
    
        private ProvisionedThroughput toProvisionedThroughput(ProvisionedTp provisionedTp) {
            log.info("creating provisioned throughput read: {} write: {}", provisionedTp.getReadCapacityUnits(), provisionedTp.getWriteCapacityUnits());
            return new ProvisionedThroughput(provisionedTp.getReadCapacityUnits(), provisionedTp.getWriteCapacityUnits());
        }
    
        private Collection<AttributeDefinition> toAttributeDefinition(Collection<AttributeDef> attributeDefs) {
            return attributeDefs.stream().map(this::toAttributeDefinition).collect(Collectors.toList());
        }
        
        private AttributeDefinition toAttributeDefinition(AttributeDef attributeDef) {
            log.info("creating new attribute definition {}: {}", attributeDef.getAttributeName(), attributeDef.getAttributeType());
            return new AttributeDefinition().withAttributeName(attributeDef.getAttributeName()).withAttributeType(attributeDef.getAttributeType());
        }
    
        private Collection<KeySchemaElement> toKeySchemaElement(Collection<KeySchema> keySchemas) {
            return keySchemas.stream().map(this::toKeySchemaElement).collect(Collectors.toList());
        }
    
        private KeySchemaElement toKeySchemaElement(KeySchema keySchema) {
            log.info("creating new key schema element {}: {}", keySchema.getAttributeName(), keySchema.getKeyType());
            return new KeySchemaElement().withAttributeName(keySchema.getAttributeName()).withKeyType(keySchema.getKeyType());
        }
    
        @Data
        @NoArgsConstructor
        public static class Table {
            @JsonProperty("TableName")
            private String tableName;
            @JsonProperty("KeySchema")
            private List<KeySchema> keySchema;
            @JsonProperty("AttributeDefinitions")
            private List<AttributeDef> attributeDefinitions;
            @JsonProperty("ProvisionedThroughput")
            private ProvisionedTp provisionedThroughput;
        }
    
        @Data
        @NoArgsConstructor
        public static class KeySchema {
            @JsonProperty("AttributeName")
            private String attributeName;
            @JsonProperty("KeyType")
            private String keyType;
        }
    
        @Data
        @NoArgsConstructor
        public static class AttributeDef {
            @JsonProperty("AttributeName")
            private String attributeName;
            @JsonProperty("AttributeType")
            private String attributeType;
        }
    
        @Data
        @NoArgsConstructor
        public static class ProvisionedTp {
            @JsonProperty("ReadCapacityUnits")
            private long readCapacityUnits;
            @JsonProperty("WriteCapacityUnits")
            private long writeCapacityUnits;
        }
    
    }