Pular para o conteúdo principal
Última atualização em

Crie um pipeline de ingestão do Jira

info

Beta

O conector Jira está em versão Beta.

Esta página descreve como criar um pipeline de ingestão do Jira usando Databricks LakeFlow Connect. Você pode ingerir o uso de dados do Jira em um Notebook, pacotes ativos Databricks ou na CLI Databricks .

Antes de começar​

Para criar um pipeline de ingestão, você deve atender aos seguintes requisitos:

  • Seu workspace deve estar habilitado para o Unity Catalog.

  • compute sem servidor (serverless compute) deve estar habilitado para seu workspace. Consulte os requisitos compute sem servidor.

  • Se você planeja criar uma nova conexão: Você deve ter privilégios CREATE CONNECTION no metastore.

    Se o conector suportar a criação pipeline baseada em interface de usuário, um administrador poderá criar a conexão e o pipeline simultaneamente, concluindo os passos desta página. No entanto, se os usuários que criam pipelines utilizarem a criação pipeline baseada em API ou não forem administradores, um administrador deverá primeiro criar a conexão no Catalog Explorer. Consulte Conectar para gerenciar fontes de ingestão.

  • Se você planeja usar uma conexão existente: Você deve ter privilégios USE CONNECTION ou ALL PRIVILEGES no objeto de conexão.

  • Você deve ter privilégios USE CATALOG no catálogo de destino.

  • Você deve ter privilégios USE SCHEMA e CREATE TABLE em um esquema existente ou privilégios CREATE SCHEMA no catálogo de destino.

Para configurar o Jira para ingestão, consulte Configurar o Jira para ingestão.

Crie um pipeline de ingestão.​

Permissões necessárias: USE CONNECTION ou ALL PRIVILEGES em uma conexão.

Você pode ingerir o uso de dados do Jira em um Notebook, pacotes ativos Databricks ou na CLI Databricks . Cada tabela que você especificar será inserida em uma tabela de transmissão ou em uma tabela de instantâneo, dependendo da origem. Consulte a referência do conector Jira para obter a lista completa de objetos disponíveis para ingestão.

  1. Copie e cole o seguinte código em uma célula do Notebook e execute-o. Não modifique nenhum trecho deste código.

    Python
    # DO NOT MODIFY


    # This sets up the API utils for creating managed ingestion pipelines in Databricks.


    import requests
    import json


    notebook_context = dbutils.notebook.entry_point.getDbutils().notebook().getContext()
    api_token = notebook_context.apiToken().get()
    workspace_url = notebook_context.apiUrl().get()
    api_url = f"{workspace_url}/api/2.0/pipelines"


    headers = {
        'Authorization': 'Bearer {}'.format(api_token),
        'Content-Type': 'application/json'
    }


    def check_response(response):
        if response.status_code == 200:
            print("Response from API:\n{}".format(json.dumps(response.json(), indent=2, sort_keys=False)))
        else:
            print(f"Failed to retrieve data: error_code={response.status_code}, error_message={response.json().get('message', response.text)}")




    def create_pipeline(pipeline_definition: str):
      response = requests.post(url=api_url, headers=headers, data=pipeline_definition)
      check_response(response)




    def edit_pipeline(id: str, pipeline_definition: str):
      response = requests.put(url=f"{api_url}/{id}", headers=headers, data=pipeline_definition)
      check_response(response)




    def delete_pipeline(id: str):
      response = requests.delete(url=f"{api_url}/{id}", headers=headers)
      check_response(response)




    def list_pipeline(filter: str):
      body = "" if len(filter) == 0 else f"""{{"filter": "{filter}"}}"""
      response = requests.get(url=api_url, headers=headers, data=body)
      check_response(response)




    def get_pipeline(id: str):
      response = requests.get(url=f"{api_url}/{id}", headers=headers)
      check_response(response)




    def start_pipeline(id: str, full_refresh: bool=False):
      body = f"""
      {{
        "full_refresh": {str(full_refresh).lower()},
        "validate_only": false,
        "cause": "API_CALL"
      }}
      """
      response = requests.post(url=f"{api_url}/{id}/updates", headers=headers, data=body)
      check_response(response)




    def stop_pipeline(id: str):
      print("cannot stop pipeline")

  2. Modifique as seguintes especificações pipeline padrão para atender às suas necessidades de ingestão. Em seguida, foi criada a célula de execução e um pipeline de ingestão. Você pode view o pipeline na seção "Tarefas e pipeline" em seu workspace.

    Você também pode filtrar os dados opcionalmente por espaços ou projetos do Jira. Certifique-se de usar a chave exata do projeto em vez de nomes ou IDs de projeto.

    (Recomendado) Segue um exemplo de ingestão de uma única tabela de origem. Consulte a referência do conector Jira para obter uma lista completa das tabelas de origem que você pode importar.

    Python
    # Example of ingesting a single table
    pipeline_spec = """
    {
      "name": "<YOUR_PIPELINE_NAME>",
      "ingestion_definition": {
        "connection_name": "<YOUR_CONNECTION_NAME>",
        "objects": [
          {
            "table": {
              "source_schema": "default",
              "source_table": "issues",
              "destination_catalog": "<YOUR_CATALOG>",
              "destination_schema": "<YOUR_SCHEMA>",
              "destination_table": "jira_issues",
              "jira_options": {
                "include_jira_spaces": ["key1", "key2"]
              }
            },
            "scd_type": "SCD_TYPE_1"
          }
        ]
      },
      "channel": "PREVIEW"
    }
    """

    create_pipeline(pipeline_spec)

    (Recomendado) Segue um exemplo de ingestão de múltiplas tabelas de origem. Consulte a referência do conector Jira para obter uma lista completa das tabelas de origem que você pode importar.

    Python
    # Example of ingesting multiple tables
    pipeline_spec = """
    {
      "name": "<YOUR_PIPELINE_NAME>",
      "ingestion_definition": {
        "connection_name": "<YOUR_CONNECTION_NAME>",
        "objects": [
          {
            "table": {
              "source_schema": "default",
              "source_table": "issues",
              "destination_catalog": "<YOUR_CATALOG>",
              "destination_schema": "<YOUR_SCHEMA>",
              "destination_table": "jira_issues",
              "jira_options": {
                "include_jira_spaces": ["key1", "key2"]
              }
            }
          },
          {
            "table": {
              "source_schema": "default",
              "source_table": "projects",
              "destination_catalog": "<YOUR_CATALOG>",
              "destination_schema": "<YOUR_SCHEMA>",
              "destination_table": "jira_projects",
              "jira_options": {
                "include_jira_spaces": ["key1", "key2"]
              }
            }
          }
        ]
      },
      "channel": "PREVIEW"
    }
    """

    create_pipeline(pipeline_spec)

    Segue abaixo um exemplo de como ingerir todas as tabelas de origem do Jira disponíveis em um único pipeline. Certifique-se de que seu aplicativo OAuth inclua todos os escopos exigidos pelo conjunto completo de tabelas e que o usuário que realiza a autenticação tenha as permissões necessárias do Jira. O pipeline falha se faltar algum escopo ou permissão necessária.

    Python
    # Example of ingesting all source tables

    pipeline_spec = """
    {
      "name": "<YOUR_PIPELINE_NAME>",
      "ingestion_definition": {
        "connection_name": "<YOUR_CONNECTION_NAME>",
        "objects": [
          {
            "schema": {
              "source_schema": "default",
              "destination_catalog": "<YOUR_CATALOG>",
              "destination_schema": "<YOUR_SCHEMA>",
              "jira_options": {
                "include_jira_spaces": ["key1", "key2"]
              }
            },
            "scd_type": "SCD_TYPE_1"
          }
        ]
      },
      "channel": "PREVIEW"
    }
    """

    create_pipeline(pipeline_spec)

Recursos adicionais​