### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

When trying to push an container image up to `localstack` via docker, and based on the advertised localstack.cloud documentation, I am then faced with multiple clues telling me that the image has in fact not been pushed to `localstack`.

### Expected Behavior

Localstack takes my container image, and I can use it to invoke a lambda function.

### How are you starting LocalStack?

With a docker-compose file

### Steps To Reproduce

file: `docker-compose.yml`
```yml
version: "3.8"

services:
  localstack:
    image: localstack/localstack:latest
    environment:
      - LOCALSTACK_API_KEY=${LOCALSTACK_API_KEY-}
      - EDGE_PORT=4566
      - LAMBDA_EXECUTOR=docker
      - LAMBDA_REMOTE_DOCKER=0
      - SERVICES=rds,vpc,lambda,dynamodb,cloudformation,s3,sts,iam,apigateway,ecr,ec2
      - HOST_TMP_FOLDER="${TMPDIR:-/tmp}/localstack"
      - DEFAULT_REGION=us-west-1
      - PORT_WEB_UI=8080
    ports:
      - '4510-4599:4510-4599'
      - '8080:8080'
    volumes:
      # - '${TMPDIR:-/tmp/localstack}:/tmp/localstack'
      - '/var/run/docker.sock:/var/run/docker.sock'
    privileged: true
```

cloudformation file: `template.yml`:
```yml
AWSTemplateFormatVersion: 2010-09-09
Resources:
  DocSvcCreateDoc:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ImageUri: localhost:4510/createdoc
```

Steps:
1. `docker-compose up`
2. In a separate terminal, once the localstack application is stood up:
```bash
$ awslocal ecr create-repository --repository-name createdoc;
$ docker build -t localhost:4510/createdoc .;
$ docker push localhost:4510/createdoc;
$ awslocal cloudformation create-stack --stack-name test --template-body file://./template.yml;
```
None of the above commands fail. (1) The repository claims to be created, (2) I can turn around and inspect that it's been created, (3) `docker push localhost:4510/createdoc` has the tell-tale racing arrows of a regular docker push, (4) `create-stack` returns figures about a stack thats been created and the `localstack` log process shows activity like somethings being done after that command.

However:
1. As I am "uploading" my docker image to localstack, the **localstack** process (not to be confused with the process running docker push) shows no indication is log output that it is even frankly receiving anything.
2. When I try to `awslocal lambda invoke` my "created" function, I am met with an error in both terminals:
```log
localstack_1  |     container_id = DOCKER_CLIENT.create_container(
localstack_1  |   File "/opt/code/localstack/localstack/utils/container_utils/docker_sdk_client.py", line 535, in create_container
localstack_1  |     raise ContainerException()
localstack_1  | localstack.utils.container_utils.container_client.ContainerException
localstack_1  | 2022-03-03T08:36:08.009:INFO:localstack_ext.services.awslambda.lambda_extended: Lambda container output: None
localstack_1  | None
```
3. When I: 
```bash
$ awslocal ecr batch-get-images \
   --repository-name createdoc \
   --image-id \
      imageDigest=<image-digest-for-localhost:4510/createdoc>,\
      imageTag=latest`:
```
I am met with:
```JSON
{
    "images": [],
    "failures": [
        {
            "imageId": {
                "imageDigest": "<image-digest-for-localhost:4510/createdoc>",
                "imageTag": "latest"
            },
            "failureCode": "ImageNotFound",
            "failureReason": "Requested image not found"
        }
    ]
}
```

Which is disheartening. Although, I get conflicting results from `list-images`:

```bash
$ awslocal ecr list-images --repository-name createdoc
```

yields

```JSON
{
    "imageIds": [
        {
            "imageDigest": "sha256:<image-digest-for-localhost:4510/createdoc>",
            "imageTag": "latest"
        }
    ]
}
```

So I'm not sure. It could be operator error. Let me know what you guys think.

### Environment

```markdown
- OS: Ubuntu 20.04 + WSL@2.0 (Windows 10)
- LocalStack: latest
```


### Anything else?

You guys are awesome.
cert_pem_file = get_cert_pem_file_path()
        return generate_ssl_cert(cert_pem_file, serial_number=serial_number)
    @classmethod
    def get_flask_ssl_context(cls, serial_number=None):
        if config.USE_SSL:
            _, cert_file_name, key_file_name = cls.create_ssl_cert(serial_number=serial_number)
            return cert_file_name, key_file_name
        return None
class UrlMatchingForwarder(ProxyListener):
    """
    ProxyListener that matches URLs to a base url pattern, and if the request url matches the
    pattern, forwards it to
    a forward_url. See TestUrlMatchingForwarder for how it behaves.
    """
    def __init__(self, base_url: str, forward_url: str) -> None:
        super().__init__()
        self.base_url = urlparse(base_url)
        self.forward_url = urlparse(forward_url)
    def forward_request(self, method, path, data, headers):
        host = headers.get("Host", "")
        if not self.matches(host, path):
            return True
        
        forward_url = self.build_forward_url(host, path)
        
        headers["Host"] = forward_url.netloc
        
        return self.do_forward(method, forward_url.geturl(), headers, data)
    def do_forward(self, method, url, headers, data):