Cómo copiar y transformar JSON a Parquet en Azure Data Factory

João Barros 26 de August de 2026 4 min de lectura

Este tutorial muestra cómo copiar archivos JSON desde un contenedor de Azure Blob Storage a archivos Parquet en un Data Lake usando Azure Data Factory, con una transformación ligera para normalizar campos. Convertir JSON a Parquet reduce costes y mejora el rendimiento en análisis.

Requisitos previos

Cuenta Azure con permisos para crear recursos
Azure Data Factory ya creado
Azure Blob Storage con algunos archivos JSON de ejemplo
Azure Data Lake Storage Gen2 u otro Blob de destino para Parquet

Paso 1: Crear Linked Services para origen y destino

Es necesario conectar Azure Data Factory al almacenamiento de origen (Blob) y al destino (ADLS Gen2 u otro Blob). Usa Managed Identity o Service Principal para evitar credenciales hardcoded.

En el portal de Azure Data Factory: Manage > Linked services > New.

// Exemplo JSON para criar Linked Service via ARM/REST (sintaxe simplificada)
{
  "name": "LS_Blob_Storage",
  "properties": {
    "type": "AzureBlobStorage",
    "typeProperties": {
      "connectionString": "DefaultEndpointsProtocol=https;AccountName=...;AccountKey=..."
    }
  }
}

Paso 2: Crear Datasets de origen JSON y destino Parquet

El Dataset de origen apunta al contenedor y la ruta con archivos JSON. El Dataset de destino debe tener formato Parquet. Configura el esquema o deja que el esquema sea inferido en Mapping Data Flow/Copy Activity.

// Dataset exemplo (simplificado)
{
  "name": "DS_Json_Incoming",
  "properties": {
    "type": "AzureBlob",
    "typeProperties": {
      "format": { "type": "JsonFormat", "filePattern": "setOfObjects" },
      "fileName": "*.json",
      "folderPath": "input/json"
    }
  }
}

// Dataset destino Parquet (simplificado)
{
  "name": "DS_Parquet_Output",
  "properties": {
    "type": "AzureBlob",
    "typeProperties": {
      "format": { "type": "ParquetFormat" },
      "folderPath": "output/parquet"
    }
  }
}

Paso 3: Decidir Copy Activity vs Mapping Data Flow

Si solo necesitas la conversión de formato (JSON → Parquet) sin transformaciones de esquema complejas, usa la Copy Activity para ser más barato y sencillo. Para normalizar campos, desagregar arrays o unir estructuras complejas, usa el Mapping Data Flow.

Paso 4: Ejemplo con Copy Activity (conversión simple)

Crea un pipeline con una actividad Copy. En el Source, selecciona el Dataset JSON y configura el file pattern; en el Sink, selecciona DS_Parquet_Output. Marca "Enable schema drift" si tienes esquemas variables.

// Copy Activity JSON->Parquet (pseudocódigo de pipeline)
{
  "name": "CopyJsonToParquet",
  "type": "Copy",
  "inputs": [{ "referenceName": "DS_Json_Incoming" }],
  "outputs": [{ "referenceName": "DS_Parquet_Output" }],
  "typeProperties": {
    "enableStaging": false
  }
}

Paso 5: Ejemplo con Mapping Data Flow (normalizar arrays)

Si los JSON contienen arrays que necesitas "explotar" en filas, crea un Mapping Data Flow con Source (formato JSON), una transformación Flatten/Unroll y luego un Sink a Parquet. Define el esquema en el Sink para Parquet.

// Flow simplificado:
Source(JSON) -> Select(columns) -> Flatten(unrollBy: items) -> DerivedColumn(normalize campos) -> Sink(Parquet)

En el Data Flow, configura la columna que contiene arrays en Unroll By. Usa Derived Column para combinar o formatear campos (ej.: concatenar id + subid).

Paso 6: Ejecutar y parametrizar para varios archivos

Para procesar múltiples archivos o carpetas, parametriza el Dataset (folderPath, fileName) y en el pipeline pasa el parámetro. Usa ForEach si necesitas lógica por archivo.

// Exemplo de parâmetro no pipeline
pipeline.parameters.folder = 'input/json'
// Passa para o Dataset: @pipeline().parameters.folder

Verificar el resultado

Valida en el destino: entra en el contenedor de destino y confirma archivos .parquet generados. Puedes abrir un archivo Parquet con Azure Storage Explorer o usar Azure Synapse/Databricks para leer. En ADF Monitor verifica la ejecución del pipeline y los logs de copia para errores comunes (incompatibilidad de esquema, permisos, archivos corruptos).

Conclusión

Convertir JSON a Parquet en Azure Data Factory mejora el rendimiento y reduce costes de almacenamiento. Empieza con la Copy Activity para escenarios simples y usa el Mapping Data Flow para normalizaciones/arrays. Siguiente paso: probar la lectura de los Parquet en Power BI o en Azure Synapse para comprobar las mejoras. Consejo: comienza con un conjunto reducido de archivos para validar esquemas antes de procesar en masa — ¿tienes preguntas sobre arrays o schema drift en tu JSON?