The answer from E.J. Brennan looks correct, for a single record, but it doesn't answer the original question (which needs to add an array of records).

For this, the command is

aws dynamodb batch-write-item --request-items file://aws-requests.json

But, you'll need to make a modified JSON file, like so (note the DynamoDB JSON that specifies data types):

{
    "YourTableName": [
        {   
            "PutRequest": {
                "Item": { 
                    "Column1": { "S": "Column1 Value" },
                    "Column2": { "S": "Column2 Value" },
                    "Column3": { "S": "Column3 Value" },
                    "Column4": { "S": "Column4 Value" },
                }
            }
        },
        {
            "PutRequest": {
                "Item": { 
                    "Column1": { "S": "Column1 Value" },
                    "Column2": { "S": "Column2 Value" },
                    "Column3": { "S": "Column3 Value" },
                    "Column4": { "S": "Column4 Value" },
                }
            }
        }
    ]
}

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.

First approach

The benefit here is that you can store arbitrary data and should not care if DynamoDB supports it. You don't even need to care if this is a valid JSON. If you are storing DynamoDB List/Maps all attributes should be of types that DynamoDB supports.

You can push this approach even further and use compression and your item will occupy less space and save you some RCUs/WCUs in the process.

The first drawback is that it is harder to work with code like this. Simply because you need to convert data back and forth and this will make your code and operations more complicated.

The second drawback, DynamoDB won't know anything about your data and won't be able to access it. For example you will not be able to use document paths feature.

Second approach

I think this is a preferred approach unless you have a good reason to stick to the first one (e.g. unusual data or size constraints).

The benefit here is that it is easier to work with, you can access all DynamoDB features and if you are using DynamoDBMapper it is really easy to implement.