I'm running the latest version of localstack using a docker-compose file. I'm trying to deploy a VPC, subnet and security group for a fleet of lambda functions using the following

```
resource "aws_vpc" "pos_vpc" {
  provider = aws.local

  cidr_block = "10.0.0.0/16"

  tags = {
    project = var.prefix
  }
}

resource "aws_subnet" "pos_aws_subnet1" {
  provider = aws.local

  availability_zone = data.aws_availability_zones.available.names[0]
  cidr_block = "10.0.1.0/24"
  vpc_id     = aws_vpc.pos_vpc.id

  tags = {
    project = var.prefix
  }
}

resource "aws_subnet" "pos_aws_subnet2" {
  provider = aws.local

  availability_zone = data.aws_availability_zones.available.names[1]
  cidr_block = "10.0.2.0/24"
  vpc_id     = aws_vpc.pos_vpc.id

  tags = {
    project = var.prefix
  }
}

resource "aws_db_subnet_group" "pos_subnet_group" {
  provider = aws.local

  name       = "${var.prefix}-${var.env_name}-subnet-group"
  subnet_ids = [aws_subnet.pos_aws_subnet1.id, aws_subnet.pos_aws_subnet2.id]

  tags = {
    project = var.prefix
  }
}

resource "aws_security_group" "pos_security_group" {
  provider = aws.local

  name       = "${var.prefix}-${var.env_name}-security-group"
  vpc_id = aws_vpc.pos_vpc.id

  ingress {
    cidr_blocks = [aws_vpc.pos_vpc.cidr_block]
    from_port   = 5432
    to_port     = 5432
    protocol    = "tcp"
  }

  egress {
    cidr_blocks = [aws_vpc.pos_vpc.cidr_block]
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
  }

  tags = {
    project = var.prefix
  }
}

```

But I get the following error:

```
 "The {0} action has not been implemented in class {1}".format(action, self.__class__))
localstack    | NotImplementedError: The describe_vpc_classic_link action has not been implemented in class <class 'moto.ec2.responses.EC2Response'>
```

Does this mean that localstack doesn't currently support VPCs?
for name, plugin in SERVICE_PLUGINS.items():
            if name in apis:
                record_service_health(name, 'starting')
                t1 = plugin.start(asynchronous=True)
                thread = thread or t1
        time.sleep(sleep_time)
        
        check_infra(apis=apis)
        
        persistence.restore_persisted_data(apis=apis)
        print('Ready.')
        sys.stdout.flush()
        if not asynchronous and thread:
            
            
            
            while True:
                time.sleep(1)
        return thread
    except KeyboardInterrupt:
        print('Shutdown')
    except Exception as e:
        print('Error starting infrastructure: %s %s' % (e, traceback.format_exc()))
        sys.stdout.flush()
        raise e
    finally:
        if not asynchronous:
            stop_infra()