Ingesta de archivos desde SharePoint

Importante

El conector de SharePoint estándar está en Beta. Los administradores del área de trabajo pueden controlar el acceso a esta característica desde la página Vistas previas . Consulte Administración de versiones preliminares de Azure Databricks.

Obtenga información sobre cómo ingerir archivos estructurados, semiestructurados y no estructurados de Microsoft SharePoint en tablas Delta. El conector de SharePoint admite la ingesta incremental de archivos de SharePoint mediante APIs por lotes y de streaming, incluido el cargador automático, spark.read y COPY INTO, todo ello con la gobernanza del Unity Catalog.

Elegir el conector de SharePoint

Lakeflow Connect ofrece dos conectores complementarios de SharePoint. Ambos acceden a datos en SharePoint, pero admiten objetivos distintos.

Consideración	Conector de SharePoint administrado	Conector estándar de SharePoint
Administración y personalización	Un conector totalmente administrado. Conectores sencillos y de bajo mantenimiento para aplicaciones empresariales que ingieren datos en tablas Delta y los mantienen sincronizados con el origen. Consulte Conectores administrados en Lakeflow Connect.	Cree canalizaciones de ingesta personalizadas con SQL, PySpark o canalizaciones declarativas de Lakeflow Spark mediante APIs de streaming y por lotes, como `read_files`, `spark.read`, `COPY INTO`, y "Auto Loader". Ofrece la flexibilidad de realizar transformaciones complejas durante la ingesta, a la vez que proporciona mayor responsabilidad para administrar y mantener las canalizaciones.
Formato de salida	Tabla de contenido binario uniforme. Ingiere cada archivo en formato binario (un archivo por fila), junto con los metadatos de archivo en columnas adicionales.	Tablas delta estructuradas. Ingiere archivos estructurados (como CSV y Excel) como tablas delta. También se puede usar para ingerir archivos no estructurados en formato binario.
Granularidad, filtrado y selección	Actualmente no hay ninguna selección de nivel de archivo o subcarpeta. No hay filtrado basado en patrones. Ingiere todos los archivos de la biblioteca de documentos de SharePoint especificada.	Granular y personalizado. Selección basada en direcciones URL para ingerir desde bibliotecas de documentos, subcarpetas o archivos individuales. También admite el filtrado basado en patrones mediante la `pathGlobFilter` opción .

Características clave

El conector estándar de SharePoint ofrece:

Ingesta de archivos estructurados, semiestructurados y no estructurados
Ingesta granular: ingiere un sitio específico, un subsitio, una biblioteca de documentos, una carpeta o un único archivo
Ingesta por lotes y en streaming mediante spark.read, Auto Loader y COPY INTO
Inferencia y evolución automáticas de esquemas para formatos estructurados y semiestructurados, como CSV y Excel
Almacenamiento seguro de credenciales con una conexión de Catálogo de Unity
Selección de archivos con coincidencia de patrones mediante pathGlobFilter

Requisitos

Para ingerir archivos desde SharePoint, debe tener lo siguiente:

Un área de trabajo con el catálogo de Unity habilitado
CREATE CONNECTION privilegios para crear una conexión de SharePoint (o USE CONNECTION para usar una existente)
Proceso que usa Databricks Runtime versión 17.3 LTS o posterior
Configuración de la autenticación de OAuth con el ámbito de permiso de Sites.Read.All
La característica Beta de SharePoint está habilitada en la página Vistas previas . Consulte Administración de versiones preliminares de Azure Databricks.
Opcional: habilite la característica Beta de Excel para analizar archivos de Excel. Consulte Leer archivos de Excel.

Creación de la conexión

Cree una conexión de Catálogo de Unity para almacenar las credenciales de SharePoint. El proceso de configuración de conexión se comparte entre los conectores estándar y administrados de SharePoint.

Para obtener instrucciones de configuración de conexión completas, incluidas las opciones de autenticación de OAuth, vea Información general sobre la configuración de ingesta de SharePoint.

Leer archivos de SharePoint

Para leer archivos de SharePoint mediante Spark, especifique la conexión que creó en el paso anterior mediante la databricks.connection opción de origen de datos y proporcione la dirección URL del recurso de SharePoint al que desea acceder. Esta dirección URL puede hacer referencia a un archivo específico, una carpeta, una biblioteca de documentos (unidad) o un sitio completo. Algunos ejemplos son:

https://mytenant.sharepoint.com/sites/test-site/
https://mytenant.sharepoint.com/sites/test-site/test-subsite
https://mytenant.sharepoint.com/sites/test-site/test-drive
https://mytenant.sharepoint.com/sites/test-site/Shared%20Documents/Forms/AllItems.aspx
https://mytenant.sharepoint.com/sites/test-site/test-drive/test-folder
https://mytenant.sharepoint.com/sites/test-site/test-drive/test-folder/test.csv
https://mytenant.sharepoint.com/sites/test-site/another-subsite/another-drive/test.csv

Examples

Busque ejemplos de código para leer archivos mediante el conector estándar de SharePoint.

Transmisión de archivos de SharePoint mediante el cargador automático

Auto Loader proporciona la manera más eficaz de ingerir archivos estructurados de forma incremental desde SharePoint. Detecta automáticamente nuevos archivos y los procesa a medida que llegan. También puede ingerir archivos estructurados y semiestructurados, como CSV y JSON, con inferencia y evolución automáticas de esquemas. Para más información sobre el uso del cargador automático, consulte Patrones comunes de carga de datos.

# Incrementally ingest new PDF files
df = (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "binaryFile")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("cloudFiles.schemaLocation", <path to a schema location>)
    .option("pathGlobFilter", "*.pdf")
    .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents")
)

# Incrementally ingest CSV files with automatic schema inference and evolution
df = (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "csv")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("pathGlobFilter", "*.csv")
    .option("inferColumnTypes", True)
    .option("header", True)
    .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs")
)

Leer archivos de SharePoint mediante la lectura por lotes de Spark

# Read unstructured data as binary files
df = (spark.read
        .format("binaryFile")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("recursiveFileLookup", True)
        .option("pathGlobFilter", "*.pdf") # optional. Example: only ingest PDFs
        .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents"))

# Read a batch of CSV files, infer the schema, and load the data into a DataFrame
df = (spark.read
        .format("csv")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("pathGlobFilter", "*.csv")
        .option("recursiveFileLookup", True)
        .option("inferSchema", True)
        .option("header", True)
        .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs"))

# Read a specific Excel file from SharePoint, infer the schema, and load the data into a DataFrame
df = (spark.read
        .format("excel")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("headerRows", 1)                   # optional
        .option("dataAddress", "'Sheet1'!A1:M20")  # optional
        .load("https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx"))

Leer archivos de SharePoint mediante Spark SQL

En el ejemplo siguiente se muestra cómo ingerir archivos de SharePoint en SQL mediante read_files la función con valores de tabla. Para obtener más información sobre el read_files uso, consulte read_files función con valores de tabla.

-- Read pdf files
CREATE TABLE my_table AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  `databricks.connection` => "my_sharepoint_conn",
  format => "binaryFile",
  pathGlobFilter => "*.pdf", -- optional. Example: only ingest PDFs
  schemaEvolutionMode => "none"
);

-- Read a specific Excel sheet and range
CREATE TABLE my_sheet_table AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx",
  `databricks.connection` => "my_sharepoint_conn",
  format => "excel",
  headerRows => 1,  -- optional
  dataAddress => "'Sheet1'!A2:D10", -- optional
  schemaEvolutionMode => "none"
);

Ingesta incremental con `COPY INTO`

COPY INTO proporciona carga incremental idempotente de archivos en una tabla Delta. Para más información sobre el COPY INTO uso, consulte Patrones comunes de carga de datos mediante COPY INTO.

CREATE TABLE IF NOT EXISTS sharepoint_pdf_table;
CREATE TABLE IF NOT EXISTS sharepoint_csv_table;
CREATE TABLE IF NOT EXISTS sharepoint_excel_table;

# Incrementally ingest new PDF files
COPY INTO sharepoint_pdf_table
  FROM "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents"
  FILEFORMAT = BINARYFILE
  PATTERN = '*.pdf'
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn')
  COPY_OPTIONS ('mergeSchema' = 'true');

# Incrementally ingest CSV files with automatic schema inference and evolution
COPY INTO sharepoint_csv_table
  FROM "https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs"
  FILEFORMAT = CSV
  PATTERN = '*.csv'
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn', 'header' = 'true', 'inferSchema' = 'true')
  COPY_OPTIONS ('mergeSchema' = 'true');

# Ingest a single Excel file
COPY INTO sharepoint_excel_table
  FROM "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx"
  FILEFORMAT = EXCEL
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn', 'headerRows' = '1')
  COPY_OPTIONS ('mergeSchema' = 'true');

Ingesta de archivos de SharePoint en canalizaciones declarativas de Spark de Lakeflow

Nota:

El conector de SharePoint requiere Databricks Runtime 17.3 o superior. Esto aún no está disponible en la versión de canalizaciones declarativas de Spark de Lakeflow. Para ver las versiones de Databricks Runtime que se usan con una versión de Canalizaciones declarativas de Spark de Lakeflow, consulte las notas de la versión de esa versión.

En los ejemplos siguientes se muestra cómo leer archivos de SharePoint mediante Auto Loader en canalizaciones declarativas de Spark de Lakeflow.

Pitón

from pyspark import pipelines as dp

# Incrementally ingest new PDF files
@dp.table
def sharepoint_pdf_table():
  return (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "binaryFile")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("pathGlobFilter", "*.pdf")
    .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents")
  )

# Incrementally ingest CSV files with automatic schema inference and evolution
@dp.table
def sharepoint_csv_table():
  return (spark.readStream.format("cloudFiles")
      .option("cloudFiles.format", "csv")
      .option("databricks.connection", "my_sharepoint_conn")
      .option("pathGlobFilter", "*.csv")
      .option("inferColumnTypes", True)
      .option("header", True)
      .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs")
  )

# Read a specific Excel file from SharePoint in a materialized view
@dp.table
def sharepoint_excel_table():
  return (spark.read.format("excel")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("headerRows", 1)                   # optional
    .option("inferColumnTypes", True)            # optional
    .option("dataAddress", "'Sheet1'!A1:M20")  # optional
    .load("https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx")

SQL

-- Incrementally ingest new PDF files
CREATE OR REFRESH STREAMING TABLE sharepoint_pdf_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  format => "binaryFile",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.pdf");

-- Incrementally ingest CSV files with automatic schema inference and evolution
CREATE OR REFRESH STREAMING TABLE sharepoint_csv_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs",
  format => "csv",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.csv",
  "header", "true");

-- Read a specific Excel file from SharePoint in a materialized view
CREATE OR REFRESH MATERIALIZED VIEW sharepoint_excel_table
AS SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx",
  `databricks.connection` => "my_sharepoint_conn",
  format => "excel",
  headerRows => 1,  -- optional
  dataAddress => "'Sheet1'!A2:D10", -- optional
  `cloudFiles.schemaEvolutionMode` => "none"
);

Análisis de archivos no estructurados

Al ingerir archivos no estructurados de SharePoint (como archivos PDF, documentos de Word o archivos de PowerPoint) mediante el conector estándar de SharePoint con binaryFile formato, el contenido del archivo se almacena como datos binarios sin procesar. Para preparar estos archivos para cargas de trabajo de INTELIGENCIA ARTIFICIAL (como RAG, búsqueda, clasificación o comprensión de documentos), puede analizar el contenido binario en una salida estructurada y consultable mediante ai_parse_document.

En el ejemplo siguiente se muestra cómo analizar documentos no estructurados almacenados en una tabla delta de bronce denominada documents, agregando una nueva columna con contenido analizado:

CREATE TABLE documents AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  `databricks.connection` => "my_sharepoint_conn",
  format => "binaryFile",
  pathGlobFilter => "*.pdf,*.docx",
  schemaEvolutionMode => "none"
);
SELECT *, ai_parse_document(content) AS parsed_content
FROM documents;

La parsed_content columna contiene texto extraído, tablas, información de diseño y metadatos que se pueden usar directamente para canalizaciones de IA de bajada.

Análisis incremental con las canalizaciones declarativas de Lakeflow Spark

También puede usar ai_parse_document en Canalizaciones declarativas de Lakeflow Spark para habilitar el análisis incremental. A medida que los nuevos archivos se transmiten desde SharePoint, se analizan automáticamente a medida que se actualiza la canalización.

Por ejemplo, puede definir una vista materializada que analice continuamente los documentos recién ingeridos:

CREATE OR REFRESH STREAMING TABLE sharepoint_documents_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  format => "binaryFile",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.pdf,*.docx");

CREATE OR REFRESH MATERIALIZED VIEW documents_parsed
AS
SELECT *, ai_parse_document(content) AS parsed_content
FROM sharepoint_documents_table;

Este enfoque garantiza que:

Los archivos de SharePoint recién ingeridos se analizan automáticamente cada vez que se actualiza la vista materializada
Las salidas analizadas permanecen sincronizadas con los datos entrantes
Las canalizaciones de IA descendentes siempre funcionan con representaciones actualizadas de documentos.

Más información: consulte ai_parse_document para conocer los formatos admitidos y las opciones avanzadas.

Limitaciones

El conector de SharePoint estándar tiene las siguientes limitaciones:

Sin ingestión de múltiples sitios: no se pueden ingerir varios sitios con la misma consulta. Para recopilar datos de dos sitios, debe escribir dos consultas separadas.
Filtrado: puede usar la pathGlobFilter opción para filtrar los archivos por nombre. No se admite el filtrado basado en la ruta de acceso de carpeta.
Formatos no admitidos: no se admiten listas de SharePoint ni páginas de sitio de .aspx. Solo se admiten archivos en bibliotecas de documentos.
No se admite la reescritura en un servidor de SharePoint.
No se admite el cargador cleanSource automático (eliminación o archivado de archivos en el origen después de la ingesta).

Pasos siguientes

Más información sobre Auto Loader para patrones avanzados de ingesta de streaming
Explora COPY INTO para cargas incrementales idempotentes
Comparación con los patrones de ingesta de almacenamiento de objetos en la nube
Configura la programación de trabajos para automatizar los flujos de trabajo de ingestión
Uso de Lakeflow Spark Declarative Pipelines para crear canalizaciones de datos de extremo a extremo con transformaciones

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-12-19