**Apache Airflow version**:

1.10.12

**Kubernetes version (if you are using kubernetes)** (use `kubectl version`):

n/a

**Environment**:

- **Cloud provider or hardware configuration**:
Amazon MWAA

- **OS** (e.g. from /etc/os-release):
Amazon Linux (latest)

- **Kernel** (e.g. `uname -a`):
n/a

- **Install tools**:
n/a

**What happened**:

If an unreachable secrets.backend is specified in airflow.cfg the web server crashes

**What you expected to happen**:

An invalid secrets backend should be ignored with a warning, and the system should default back to the metadatabase secrets

**How to reproduce it**:

In an environment without access to AWS Secrets Manager, add the following to your airflow.cfg:

```
[secrets]
backend = airflow.contrib.secrets.aws_secrets_manager.SecretsManagerBackend
```
**or** an environment without access to SSM specifiy:

```
[secrets]
backend = airflow.contrib.secrets.aws_systems_manager.SystemsManagerParameterStoreBackend
```

Reference: https://airflow.apache.org/docs/apache-airflow/1.10.12/howto/use-alternative-secrets-backend.html#aws-ssm-parameter-store-secrets-backend
airflow/models/connection.py
"""Extra data. The value is decrypted/encrypted when reading/setting the value."""
        return synonym('_extra', descriptor=property(cls.get_extra, cls.set_extra))
    def rotate_fernet_key(self):
        """Encrypts data with a new key. See: :ref:`security/fernet`"""
        fernet = get_fernet()
        if self._password and self.is_encrypted:
            self._password = fernet.rotate(self._password.encode('utf-8')).decode()
        if self._extra and self.is_extra_encrypted:
            self._extra = fernet.rotate(self._extra.encode('utf-8')).decode()
    def get_hook(self):
        """Return hook based on conn_type."""
        (
            hook_class_name,
            conn_id_param,
            package_name,
            hook_name,
            connection_type,
        ) = ProvidersManager().hooks.get(self.conn_type, (None, None, None, None, None))
        if not hook_class_name:
            raise AirflowException(f'Unknown hook type "{self.conn_type}"')
        try:
            hook_class = import_string(hook_class_name)
        except ImportError:
            warnings.warn(
                "Could not import %s when discovering %s %s", hook_class_name, hook_name, package_name
            )
            raise
        return hook_class(**{conn_id_param: self.conn_id})
    def __repr__(self):