> ## Documentation Index
> Fetch the complete documentation index at: https://docs.open-metadata.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Run the SSRS Connector Externally

> Use YAML to configure SQL Server Reporting Services (SSRS) dashboard connections with metadata ingestion and report extraction.

![SSRS](https://docs.open-metadata.org/public/images/connectors/ssrs.webp)

# SSRS

PROD

In this section, we provide guides and references to use the SSRS connector.

Configure and schedule SSRS metadata workflows from the OpenMetadata UI:

* [Requirements](#requirements)
* [Metadata Ingestion](#metadata-ingestion)

## How to Run the Connector Externally

To run the Ingestion via the UI you'll need to use the OpenMetadata Ingestion Container, which comes shipped with
custom Airflow plugins to handle the workflow deployment.

If, instead, you want to manage your workflows externally on your preferred orchestrator, you can check
the following docs to run the Ingestion Framework **anywhere**.

> [card] [External Schedulers](https://docs.open-metadata.org/v2.0.x/deployment/ingestion.md)
>
> Get more information about running the Ingestion Framework Externally

## Requirements

The SSRS connector uses the [SSRS REST API](https://docs.microsoft.com/en-us/sql/reporting-services/developer/rest-api) (v2.0) and authenticates via **Windows Authentication (NTLM)**. The account used must have at minimum **Browser** role on the SSRS Report Server to list folders and reports.

> [!NOTE]
>
> The SSRS REST API (v2.0) requires **SQL Server Reporting Services 2017 or later**. Older SSRS versions using SOAP-based web services are not supported.

To grant the required role:

1. Open the **SSRS Web Portal**.
2. Navigate to **Site Settings** → **Security** → **New Role Assignment**.
3. Add the service account and assign the **Browser** role.

### Python Requirements

Use Python 3.10 or later. Python 3.12 is recommended, because it is what the OpenMetadata 2.0 ingestion images use. To confirm the supported range for your release, check the `Requires-Python` metadata of that release’s `openmetadata-ingestion` package.

To run the SSRS ingestion, you will need to install:

```bash theme={null}
pip3 install "openmetadata-ingestion[ssrs]"
```

## Metadata Ingestion

All connectors are defined as JSON Schemas.
[Here](https://github.com/open-metadata/OpenMetadata/blob/main/openmetadata-spec/src/main/resources/json/schema/entity/services/connections/dashboard/ssrsConnection.json)
you can find the structure to create a connection to SSRS.

In order to create and run a Metadata Ingestion workflow, we will follow
the steps to create a YAML configuration able to connect to the source,
process the Entities if needed, and reach the OpenMetadata server.

The workflow is modeled around the following
[JSON Schema](https://github.com/open-metadata/OpenMetadata/blob/main/openmetadata-spec/src/main/resources/json/schema/metadataIngestion/workflow.json)

### 1. Define the YAML Config

#### Source Configuration

Configure the source type and service name for your SSRS connector.

#### Host and Port

**hostPort**: The base URL of your SSRS web portal, for example, `https://your-ssrs-server/Reports`. The connector appends `/api/v2.0` to this URL when calling the REST API. Use the web portal path (default `/Reports`), not the Report Server SOAP/URL-access endpoint (`/ReportServer`). The `/ReportServer` endpoint serves HTML and fails with `Failed to connect to SSRS: Expecting value: line 1 column 1 (char 0)`.

#### Username

**username**: The Windows account username for NTLM authentication. Use `DOMAIN\username` format for domain accounts.

#### Password

**password**: Password for the Windows account used for NTLM authentication.

#### Verify SSL

**verifySSL** *(optional)*: Controls SSL certificate verification — `no-ssl` (default), `ignore`, or `validate`.

#### SSL Configuration

**sslConfig** *(optional)*: Required when `verifySSL` is `validate`. Provide the CA certificate to verify the SSRS server's SSL certificate.

#### Filter Patterns

**dashboardFilterPattern**, **chartFilterPattern**, **projectFilterPattern** *(optional)*: Regex patterns to include or exclude SSRS reports, charts, and folders from ingestion.

#### Source Config

The `sourceConfig` is defined [here](https://github.com/open-metadata/OpenMetadata/blob/main/openmetadata-spec/src/main/resources/json/schema/metadataIngestion/dashboardServiceMetadataPipeline.json):

* **dbServiceNames**: Database Service Names for ingesting lineage if the source supports it.
* **dashboardFilterPattern**, **chartFilterPattern**, **dataModelFilterPattern**: Note that all of them support regex as include or exclude. For example, `My dashboard`, `My dash.*`, and `.*Dashboard`.
* **projectFilterPattern**: Filter the dashboards, charts and data sources by projects. Note that all of them support regex as include or exclude. For example, `My project`, `My proj.*`, and `.*Project`.
* **includeOwners**: Set the **Include Owners** toggle to control whether to include owners to the ingested entity if the owner email matches with a user stored in the OM server as part of metadata ingestion. If the ingested entity already exists and has an owner, the owner will not be overwritten. It supports boolean values either `true` or `false`.
* **includeTags**: Optional configuration to toggle the tags ingestion. It supports boolean values either `true` or `false`.
* **includeDataModels**: Optional configuration to toggle the ingestion of data models. It supports boolean values either `true` or `false`.
* **markDeletedDashboards**: Optional configuration to soft delete dashboards in OpenMetadata if the source dashboards are deleted. Also, if the dashboard is deleted, all the associated entities like lineage, etc., with that dashboard will be deleted. It supports boolean values either `true` or `false`.
* **markDeletedDataModels**: Optional configuration to soft delete data models in OpenMetadata if the source data models are deleted. Also, if the data model is deleted, all the associated entities like lineage, etc., with that data model will be deleted. It supports boolean values either `true` or `false`.
* **includeDraftDashboard**: Optional configuration to include or exclude draft dashboards. By default it will include draft dashboards. It supports boolean values either `true` or `false`.
* **overrideMetadata**: Set the **Override Metadata** toggle to control whether to override the existing metadata in the OpenMetadata server with the metadata fetched from the source. If the toggle is set to true, the metadata fetched from the source will override the existing metadata in the OpenMetadata server. If the toggle is set to false, the metadata fetched from the source will not override the existing metadata in the OpenMetadata server. This is applicable for fields like description, tags, owner, and displayName. It supports boolean values either `true` or `false`.
* **overrideLineage**: Set the **Override Lineage** toggle to control whether to override the existing lineage. It supports boolean values either `true` or `false`.

#### Sink Configuration

To send the metadata to OpenMetadata, it needs to be specified as `type: metadata-rest`.

#### Workflow Configuration

The main property here is `openMetadataServerConfig`, where you can define the host and security provider of your OpenMetadata installation.

* **loggerLevel**: Specify the logger level depending on your needs. If you are troubleshooting an ingestion, use `DEBUG` for more detailed traces.
* **JWT token**: JWT tokens allow clients to authenticate against the OpenMetadata server. See [Enable JWT Tokens](https://docs.open-metadata.org/deployment/security/enable-jwt-tokens.md) and [JWT Troubleshooting](https://docs.open-metadata.org/deployment/security/jwt-troubleshooting.md) for more information.
* **storeServiceConnection**: If set to `true` (default), sensitive information is stored encrypted with the Fernet Key or externally if you have configured a [Secrets Manager](https://docs.open-metadata.org/deployment/secrets-manager.md). If set to `false`, the service is created, but the service connection information is only used by the Ingestion Framework at runtime and is not sent to the OpenMetadata server.
* **SSL configuration**: If you have added SSL to the [OpenMetadata server](https://docs.open-metadata.org/deployment/security/enable-ssl.md), configure the certificates for ingestion. Set `verifySSL` to `ignore`, or set it to `validate` and provide `sslConfig.caCertificate` with a local path to the server certificate. See [SSL Troubleshooting](https://docs.open-metadata.org/deployment/security/enable-ssl/ssl-troubleshooting.md) for more information.
* **ingestionPipelineFQN**: Fully qualified name of the ingestion pipeline, used to identify the current ingestion pipeline.

ssrs\_config.yaml
Copy full code

```yaml theme={null}
source:
  type: ssrs
  serviceName: <service_name>
  serviceConnection:
    config:
      type: Ssrs
      hostPort: <https://your-ssrs-server/Reports>
      username: <username>
      password: <password>
      # verifySSL: no-ssl
      # sslConfig:
      #   caCertificate: <path-to-ca-cert>
      # dashboardFilterPattern:
      #   includes:
      #     - ".*"
      #   excludes: []
      # chartFilterPattern:
      #   includes:
      #     - ".*"
      #   excludes: []
      # projectFilterPattern:
      #   includes:
      #     - ".*"
      #   excludes: []
```

```yaml theme={null}
  sourceConfig:
    config:
      type: DashboardMetadata
      # lineageInformation:
      #   dbServiceNames:
      #     - service1
      #     - service2
      # dashboardFilterPattern:
      #   includes:
      #     - dashboard1
      #     - dashboard2
      #   excludes:
      #     - dashboard3
      #     - dashboard4
      # chartFilterPattern:
      #   includes:
      #     - chart1
      #     - chart2
      #   excludes:
      #     - chart3
      #     - chart4
      # projectFilterPattern:
      #   includes:
      #     - project1
      #     - project2
      #   excludes:
      #     - project3
      #     - project4
      # dataModelFilterPattern:
      #   includes:
      #     - dataModel1
      #     - dataModel2
      #   excludes:
      #     - dataModel3
      #     - dataModel4
      # includeOwners: false # true
      # markDeletedDashboards: true # false
      # markDeletedDataModels: true # false
      # includeTags: true # false
      # includeDataModels: true # false
      # includeDraftDashboard: true # false
      # overrideMetadata: false # true
      # overrideLineage: false # true
```

```yaml theme={null}
sink:
  type: metadata-rest
  config: {}
```

```yaml theme={null}
workflowConfig:
  loggerLevel: INFO  # DEBUG, INFO, WARNING or ERROR
  openMetadataServerConfig:
    hostPort: "http://localhost:8585/api"
    authProvider: openmetadata
    securityConfig:
      jwtToken: "{bot_jwt_token}"
    ## Store the service Connection information
    storeServiceConnection: true  # false
    ## Secrets Manager Configuration
    # secretsManagerProvider: aws, azure or noop
    # secretsManagerLoader: airflow or env
    ## If SSL, fill the following
    # verifySSL: validate  # or ignore
    # sslConfig:
    #   caCertificate: /local/path/to/certificate
# ingestionPipelineFQN: <service name>.<ingestion name> ## e.g., "my_redshift.metadata"
```

### 2. Run with the CLI

First, we will need to save the YAML file. Afterward, and with all requirements installed, we can run:

```bash theme={null}
metadata ingest -c <path-to-yaml>
```

Note that from connector to connector, this recipe will always be the same. By updating the YAML configuration,
you will be able to extract metadata from different sources.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.