### 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();
    }
```
"""
    This decorator hides the difference between an XML node with text or a plain string.
    It's used to ensure that scalar processing operates only on text strings, which
    allows the same scalar handlers to be used for XML nodes from the body, HTTP headers,
    and across different protocols.
    :param func: function which should be wrapped
    :n: wrapper function which can be called with a node or a string, where the
             wrapped function is always called with a string
    """
    def _get_text_content(
        self,
        request: HttpRequest,
        shape: Shape,
        node_or_string: Union[ETree.Element, str],
        
    ):
        if hasattr(node_or_string, "text"):
            text = node_or_string.text
            if text is None:
                # If an XML node is empty <foo></foo>, we want to parse that as an empty string,
                # not as a null/None value.
                text = ""
        else:
            text = node_or_string
        n func(self, request, shape, text, uri_params)
    n _get_text_content
class RequesrError(Exception):