### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

I'm using Debezium for writing changes to a Postgres database to Kinesis. Certain calls to put object succeed using production Kinesis but fail using localstack.

One such record produces the following exception logs:
```
Traceback (most recent call last):
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 264, in _parse_shape
    return handler(request, shape, payload, uri_params) if payload is not None else None
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 122, in _get_text_content
    return func(self, request, shape, text, uri_params)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 295, in _parse_blob
    return base64.b64decode(node)
  File "/usr/local/lib/python3.10/base64.py", line 87, in b64decode
    return binascii.a2b_base64(s)
binascii.Error: Incorrect padding

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/opt/code/localstack/localstack/aws/chain.py", line 57, in handle
    handler(self, self.context, response)
  File "/opt/code/localstack/localstack/aws/handlers/service.py", line 62, in __call__
    return self.parse_and_enrich(context)
  File "/opt/code/localstack/localstack/aws/handlers/service.py", line 75, in parse_and_enrich
    operation, instance = parser.parse(context.request)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 174, in wrapper
    return func(*args, **kwargs)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 914, in parse
    final_parsed = self._do_parse(request, shape, uri_params)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 926, in _do_parse
    parsed = self._handle_json_body(request, shape, uri_params)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 939, in _handle_json_body
    return self._parse_shape(request, shape, parsed_json, uri_params)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 264, in _parse_shape
    return handler(request, shape, payload, uri_params) if payload is not None else None
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 849, in _parse_structure
    parsed = self._parse_shape(request, member_shape, raw_value, uri_params)
  File "/opt/code/localstack/localstack/aws/protocol/parser.py", line 266, in _parse_shape
    raise ProtocolParserError(
localstack.aws.protocol.parser.ProtocolParserError: Invalid type when parsing Data: 'b'{"before":null,"after":{"id":1,"account_id":1,"primary_watchlist_id":null,"primary_searchlist_id":null},"source":{"version":"1.9.5.Final","connector":"postgresql","name":"dbsync","ts_ms":1658352377055,"snapshot":"true","db":"mydb","sequence":"[null,\\"39039528\\"]","schema":"public","table":"account_settings","txId":723,"lsn":39039528,"xmin":null},"op":"r","ts_ms":1658352377055,"transaction":null}'' cannot be parsed to blob.
```

### Expected Behavior

The call to put object with the record described above should succeed.

### How are you starting LocalStack?

With a docker-compose file

### Steps To Reproduce

I've started localstack with
```
docker compose up -d localstack
```
with the following entry in my compose file
```
localstack:
  container_name: localstack # required to run correctly
  image: localstack/localstack
  ports:
    - "4566:4566"
    - "4510-4559:4510-4559"
  environment:
    DEBUG: 1
    DOCKER_HOST: unix:///var/run/docker.sock
    KINESIS_INITIALIZE_STREAMS: dbsync:1,dbsync.events:1
  volumes:
    - ./dbsync/localstack:/var/lib/localstack
    - /var/run/docker.sock:/var/run/docker.sock
```

### Environment

```markdown
- OS: MacOS Monterey (12.4)
- LocalStack: latest
```


### Anything else?

The code responsible for making put object calls can be [found here](https://github.com/debezium/debezium/blob/main/debezium-server/debezium-server-kinesis/src/main/java/io/debezium/server/kinesis/KinesisChangeConsumer.java#L108-L113) from the Debezium codebase.
```
    @Override
    public void handleBatch(List<ChangeEvent<Object, Object>> records, RecordCommitter<ChangeEvent<Object, Object>> committer)
            throws InterruptedException {
        for (ChangeEvent<Object, Object> record : records) {
            LOGGER.trace("Received event '{}'", record);
            Object rv = record.value();
            if (rv == null) {
                rv = "";
            }

            final PutRecordRequest putRecord = PutRecordRequest.builder()
                    .partitionKey((record.key() != null) ? getString(record.key()) : nullKey)
                    .streamName(streamNameMapper.map(record.destination()))
                    .data(SdkBytes.fromByteArray(getBytes(rv)))
                    .build();
            client.putRecord(putRecord);
            committer.markProcessed(record);
        }
        committer.markBatchFinished();
    }
```
Creates the right parser for the given service model.
    **Experimental:** The parsers in this module are still experimental.
    When implementing services with these parsers, some edge cases might
    not work out-of-the-box.
    :param service: to create the parser for
    :n: Requesr which can handle the protocol of the service
    """
    # Unfortunately, some services show subtle differences in their parsing or operation detection behavior, even though
    # their specification states they implement the same protocol.
    # In order to avoid bundling the whole complexity in the specific protocols, or even have service-distinctions
    #  the service-specific parser implementations (basically the implicit /
    # informally more specific protocol implementation) has precedence over the more general protocol-specific parsers.
    service_specific_parsers = {
        "s3": S3Requesr,
        "sqs": SQSRequesr,
    }
    protocol_specific_parsers = {
        "query": QueryRequesr,
        "json": JSONRequesr,
        "rest-json": RestJSONRequesr,
        "rest-xml": RestXMLRequesr,
        "ec2": EC2Requesr,
    }
    # Try to select a service-specific parser implementation
    if service.service_name in service_specific_parsers:
        n service_specific_parsers[service.service_name](service)
    else:
        # Otherwise, pick the protocol-specific parser for the protocol of the service
        n protocol_specific_parsers[service.protocol](service)