Microsoft Fabric
Tutorial de Microsoft Fabric Notebook: de tu primer notebook a producción
Un tutorial práctico de notebooks en Microsoft Fabric: Lakehouse, PySpark, SQL, tablas Delta, parámetros, pipelines, Git, monitoreo, rendimiento y producción.
En este artículo
Un notebook de Microsoft Fabric puede empezar como unas pocas celdas de exploración y convertirse rápidamente en parte de una plataforma de datos en producción.
En esa transición es donde muchos equipos tienen dificultades.
Crear un notebook es fácil. Construir uno que esté parametrizado, sea observable, repetible, esté bajo control de versiones y sea seguro de ejecutar desde un pipeline requiere una ingeniería más deliberada.
Este tutorial recorre ese camino completo.
El objetivo no es solo mostrar cómo ejecutar PySpark en Fabric. Es mostrar cómo encaja un notebook en un flujo real de data engineering:
- Workspace
- Lakehouse
- Notebook
- Transformación
- Tablas Delta
- Pipeline
- Monitoreo
- Git / despliegue
Al terminar, deberías entender cómo pasar de un notebook interactivo a algo que puedas operar como parte de una plataforma de datos en producción.
Qué es un notebook de Microsoft Fabric
Un notebook de Fabric es una superficie de desarrollo interactiva para cargas de trabajo de Apache Spark dentro de Microsoft Fabric.
Puedes usarlo para:
- explorar datos;
- leer y escribir datos del Lakehouse;
- transformar grandes conjuntos de datos con PySpark;
- ejecutar Spark SQL;
- trabajar con tablas Delta;
- parametrizar el procesamiento;
- ejecutar notebooks desde pipelines de Data Factory;
- integrar el código fuente del notebook con Git;
- operacionalizar transformaciones de datos recurrentes.
Los notebooks de Fabric son especialmente útiles cuando la transformación necesita Spark, procesamiento distribuido o un flujo de trabajo basado en código.
Un notebook no es automáticamente la mejor herramienta para cualquier tarea. Las operaciones de copia simples pueden encajar mejor en una actividad de pipeline. Las transformaciones en T-SQL pueden encajar mejor en un Warehouse. Los pasos pequeños de orquestación quizá no necesiten Spark en absoluto.
El notebook es una herramienta más dentro de la plataforma.
Requisitos previos
Para los ejercicios de este tutorial necesitas:
- acceso a un tenant de Microsoft Fabric;
- un workspace asignado a una capacidad de Fabric o a una prueba elegible;
- permiso para crear elementos en ese workspace;
- un Lakehouse;
- un notebook.
Un workspace de desarrollo práctico podría verse así:
Workspace: data-platform-dev
Lakehouse: lh_sales
Notebook: nb_transform_sales
Para entornos de producción, usa workspaces separados para desarrollo, pruebas y producción, en lugar de tratar un único workspace como si fuera todos los entornos.
Paso 1: crear tu primer notebook de Microsoft Fabric
En un espacio de trabajo de Fabric, selecciona Nuevo elemento, busca Notebook, selecciónalo y dale un nombre claro, como demo_javibuilds.

Crea un notebook desde la experiencia Nuevo elemento del espacio de trabajo de Fabric.
Paso 2: conocer el espacio de trabajo del notebook
Un notebook nuevo de Fabric comienza con una celda de código. El menú de lenguajes ofrece PySpark (Python), Spark (Scala), Spark SQL, SparkR (R) y HTML. Este tutorial usa principalmente PySpark para transformaciones con DataFrames y lógica Python, y Spark SQL cuando SQL expresa mejor la transformación.

Un notebook de Fabric puede ejecutar celdas PySpark, Spark SQL, Scala, R y HTML.
Paso 3: crear o adjuntar un Lakehouse
El Lakehouse almacena las tablas Delta de este tutorial. En Elementos de datos, selecciona Añadir elementos de datos y adjunta un Lakehouse existente o crea uno llamado demo. Después, el Explorador muestra Tables y Files, que el código puede leer y escribir directamente.

Crea o adjunta un Lakehouse desde el panel Elementos de datos del notebook.
Paso 4: cómo encajan el notebook, el Lakehouse y el punto de conexión de análisis SQL
Antes de escribir más código, conviene ver cómo se relacionan entre sí los elementos que acabas de crear.
Un workspace de Fabric es un contenedor de elementos de Fabric. En este tutorial contiene el Lakehouse y el notebook que creaste, además de un elemento que Fabric creó por ti:
Workspace
├─ Lakehouse (demo)
│ ├─ Tables
│ ├─ Files
│ └─ Punto de conexión de análisis SQL
└─ Notebook (demo_javibuilds)
└─ lee/escribe tablas Delta en el Lakehouse
- El Lakehouse es un elemento de Fabric que almacena datos en OneLake, como tablas y como archivos.
- Cuando creas un Lakehouse, Fabric crea automáticamente un punto de conexión de análisis SQL para él. Ese punto de conexión no es una segunda copia de los datos: expone las tablas Delta del Lakehouse a SQL y lee las mismas tablas en OneLake.
- El notebook es un elemento independiente dentro del mismo workspace. No almacena los datos por sí mismo; una vez adjuntado el Lakehouse, el código del notebook lee y escribe las tablas Delta y los archivos del Lakehouse.
- El punto de conexión de análisis SQL permite que los usuarios y las herramientas de SQL consulten esas mismas tablas del Lakehouse con SQL, sin abrir un notebook. El paso 11 lo muestra en funcionamiento.

Un workspace de Fabric puede contener el Lakehouse, su punto de conexión de análisis SQL y el notebook que procesa sus datos.
Paso 5: Tables y Files dentro de un Lakehouse de Fabric
El Explorador del Lakehouse muestra dos áreas: Tables y Files. Ambas están en OneLake, pero cumplen funciones distintas.
Tables
- tablas Delta administradas que puedes consultar;
- visibles por su nombre desde Spark, por ejemplo
spark.table("demo_customers"); - consultables a través del punto de conexión de análisis SQL;
- adecuadas para datos estructurados y curados, como
demo_customersydemo_sales.
Files
- almacenamiento de archivos de uso general en OneLake;
- útil para archivos CSV, JSON, Parquet y otros formatos;
- se usa a menudo para datos sin procesar de aterrizaje o de staging;
- un archivo en Files no se convierte automáticamente en una tabla administrada del Lakehouse: lo cargas en una tabla, por ejemplo con
saveAsTable().
| Tables | Files | |
|---|---|---|
| Contiene | Tablas Delta administradas | Archivos de cualquier formato (CSV, JSON, Parquet…) |
| Lectura desde Spark | spark.table("demo_customers") |
spark.read.csv("Files/raw/customers.csv") |
| Punto de conexión de análisis SQL | Consultables como tablas | No se exponen como tablas |
| Uso típico | Datos estructurados y curados | Datos sin procesar de aterrizaje y staging |
La captura siguiente muestra el Lakehouse después de los pasos siguientes: demo_customers y demo_sales en Tables, y una carpeta raw en Files.

Un Lakehouse de Fabric separa las tablas administradas del almacenamiento general de archivos y mantiene ambos en OneLake.
Paso 6: crear una tabla Delta con PySpark
Crea un pequeño DataFrame de Spark y guárdalo como una tabla Delta administrada en el Lakehouse adjunto:
from pyspark.sql import Row
data = [
Row(customer_id=1, customer_name="Alice", country="USA"),
Row(customer_id=2, customer_name="Bob", country="Canada"),
Row(customer_id=3, customer_name="Carlos", country="Spain"),
]
df = spark.createDataFrame(data)
df.write \
.format("delta") \
.mode("overwrite") \
.saveAsTable("demo_customers")Verifica la tabla:
spark.table("demo_customers").show()
createDataFrame() crea el DataFrame de Spark, format("delta") selecciona el formato Delta y saveAsTable("demo_customers") registra la tabla bajo Tables en el Lakehouse adjunto.

PySpark crea demo_customers como tabla Delta en el Lakehouse adjunto.
Paso 7: crear y consultar la tabla con Spark SQL
También puedes crear la misma tabla Delta con Spark SQL. Es Spark SQL ejecutado en la sesión Spark del notebook, no el punto de conexión SQL de Fabric Warehouse ni T-SQL de SQL Server. El paso 11 muestra el punto de conexión de análisis SQL propio del Lakehouse.
CREATE OR REPLACE TABLE demo_customers
USING DELTA
AS
SELECT 1 AS customer_id, 'Alice' AS customer_name, 'USA' AS country
UNION ALL
SELECT 2, 'Bob', 'Canada'
UNION ALL
SELECT 3, 'Carlos', 'Spain';Después, consúltala:
SELECT *
FROM demo_customers;
Spark SQL puede crear y consultar la misma tabla Delta sin salir del notebook.
PySpark frente a Spark SQL: ambos se ejecutan en Spark y trabajan con las mismas tablas Delta. Usa PySpark para DataFrames y lógica Python, y Spark SQL cuando SQL resulte más claro.
Paso 8: crear datos de ventas de ejemplo
Crea una segunda tabla Delta para disponer de datos realistas que transformar:
CREATE OR REPLACE TABLE demo_sales
USING DELTA
AS
SELECT 1001 AS order_id, 1 AS customer_id, 125.50 AS amount, 'USA' AS country
UNION ALL
SELECT 1002, 2, 89.99, 'Canada'
UNION ALL
SELECT 1003, 1, 210.00, 'USA';
Una segunda tabla Delta proporciona datos para transformar con PySpark.
Paso 9: transformar datos del Lakehouse con PySpark
Lee demo_sales, añade una clasificación de negocio derivada y revisa el resultado:
from pyspark.sql import functions as F
sales_df = spark.table("demo_sales")
enriched_df = (
sales_df
.withColumn(
"order_size",
F.when(F.col("amount") >= 150, "Large")
.when(F.col("amount") >= 100, "Medium")
.otherwise("Small")
)
)
display(enriched_df)El código lee una tabla Delta del Lakehouse adjunto, añade order_size y muestra el DataFrame transformado de forma interactiva.

Lee una tabla Delta del Lakehouse con PySpark, añade una columna derivada y revisa el resultado de forma interactiva.
El Lakehouse adjunto sigue visible en el Explorador del notebook mientras trabajas, así que ves las tablas Delta que lee el código, como demo_sales, junto a las filas transformadas:

Con el Lakehouse adjunto, PySpark lee directamente las tablas Delta y muestra los resultados transformados en el mismo notebook.
Agrupa el resultado por país:
country_summary_df = (
enriched_df
.groupBy("country")
.agg(
F.count("*").alias("order_count"),
F.round(F.sum("amount"), 2).alias("total_sales"),
F.round(F.avg("amount"), 2).alias("avg_order_amount")
)
.orderBy(F.desc("total_sales"))
)
display(country_summary_df)Guarda el resumen reutilizable en el Lakehouse:
(
country_summary_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("demo_sales_by_country")
)overwrite es práctico para este tutorial, pero una carga de producción puede necesitar anexado, reemplazo de particiones, MERGE, procesamiento incremental o actualizaciones idempotentes. Pregúntate siempre qué ocurre si el notebook se ejecuta dos veces.
Paso 10: cargar archivos sin procesar en Files/raw
Los pipelines reales rara vez empiezan con filas escritas a mano. Los sistemas de origen suelen entregar archivos, y el área Files del Lakehouse es el lugar natural para recibirlos antes de convertirlos en tablas Delta.
Una organización posible:
Files/raw/
customers.csv
products.csv
purchase_orders.csv
sales_order_lines.csv
sales_orders.csv
Es solo un ejemplo de organización, no un requisito de Fabric. Elige carpetas que se ajusten a tus fuentes y a tus necesidades de retención, por ejemplo por sistema de origen, por fecha de carga o por tenant.

El área Files es el lugar natural para recibir los archivos de origen sin procesar antes de transformarlos en tablas Delta.
Lee uno de los archivos con PySpark:
raw_customers_df = (
spark.read
.option("header", True)
.option("inferSchema", True)
.csv("Files/raw/customers.csv")
)
display(raw_customers_df)inferSchema es práctico para explorar un archivo. Para la ingesta en producción, declara un esquema explícito con .schema(...), de modo que un cambio de tipo en la fuente se detecte en lugar de inferirse en silencio.
Después cárgalo en una tabla Delta administrada:
(
raw_customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("demo_customers_from_file")
)Tras esta escritura, demo_customers_from_file aparece en Tables y el archivo CSV sigue en Files/raw/. El archivo en sí no se convirtió en una tabla: el notebook creó una nueva tabla Delta a partir de él.
Paso 11: consultar las tablas del Lakehouse a través del punto de conexión de análisis SQL
Las tablas Delta que creaste no son solo para Spark. Abre el punto de conexión de análisis SQL del Lakehouse desde el workspace, o cambia la vista del Lakehouse a Punto de conexión de análisis SQL, y consulta las tablas con SQL:
SELECT TOP (100)
customer_id,
customer_name,
country
FROM dbo.demo_customers;
El punto de conexión de análisis SQL del Lakehouse permite a los usuarios de SQL consultar las mismas tablas sin abrir un notebook.
Es una experiencia distinta de las celdas %%sql del paso 7. Spark SQL se ejecuta a través de Spark dentro del notebook; el punto de conexión de análisis SQL ofrece una experiencia de consulta SQL fuera del notebook, sobre las mismas tablas del Lakehouse.
| Spark SQL en el notebook | Punto de conexión de análisis SQL |
|---|---|
| Se ejecuta a través de Spark | Experiencia del punto de conexión SQL |
| Se usa dentro de los notebooks | Se usa desde el editor de consultas SQL y herramientas SQL |
| Adecuado para flujos que combinan PySpark y SQL | Adecuado para consultas orientadas a SQL |
| Funciona mediante la ejecución de Spark | Expone las tablas del Lakehouse mediante SQL |
| Puede escribir tablas Delta | Solo lectura para los datos de las tablas del Lakehouse |
Ambos leen las mismas tablas Delta en OneLake; no se copia nada entre ellos. Las tablas que crea el notebook, como demo_sales_by_country en el paso 9, también pasan a poder consultarse desde el punto de conexión, normalmente tras una breve sincronización de metadatos.
Paso 12: parametrizar el notebook
Evita los valores de ejecución fijos en el código:
process_date = "2026-10-09"
tenant_id = 42
Los notebooks de Fabric admiten una celda de parámetros designada.
Una celda de parámetros puede definir valores predeterminados como:
process_date = "2026-10-09"
tenant_id = 0
full_reload = FalseCuando un pipeline de Fabric invoca el notebook, la actividad Notebook puede proporcionar los valores de los parámetros.
Los parámetros de notebook admiten tipos simples como string, int, float y bool.
Una estructura útil es:
- 1Parámetros
- 2Validar los parámetros
- 3Resolver la configuración
- 4Ejecutar la transformación
- 5Escribir el resultado
Paso 13: ejecutar el notebook desde un pipeline de Fabric
Crea un pipeline de Fabric Data Factory y añade una actividad Notebook.
El pipeline puede seleccionar el notebook y pasarle parámetros base.
- Pipeline
- Actividad Notebook
- parámetros basenb_transform_sales
- process_date
- tenant_id
Normalmente, el pipeline debe encargarse de las programaciones, las dependencias, los reintentos, la secuencia y el estado general de la ejecución.
Normalmente, el notebook debe encargarse de la lógica de transformación, la validación, los controles de calidad de datos y las escrituras.
Paso 14: añadir registro de ejecución
Un notebook de producción debe permitirte responder:
¿Qué ejecución falló?
¿Para qué tenant?
¿Para qué fecha de proceso?
¿Cuándo empezó?
¿Cuándo terminó?
¿Cuántas filas se leyeron?
¿Cuántas se escribieron?
¿Qué error ocurrió?
Como mínimo, establece un contexto de ejecución:
from datetime import datetime, timezone
import uuid
run_id = str(uuid.uuid4())
started_at = datetime.now(timezone.utc)
print(f"run_id={run_id}")
print(f"tenant_id={tenant_id}")
print(f"process_date={process_date}")
print(f"started_at={started_at.isoformat()}")En una plataforma real, guarda la información de ejecución en una tabla de log de ejecuciones.
Los campos útiles suelen incluir:
run_id
parent_run_id
pipeline_name
notebook_name
tenant_id
process_date
status
started_at
ended_at
rows_read
rows_written
rows_rejected
error_code
error_message
Paso 15: fallar de forma deliberada cuando falla la validación
Un notebook peligroso detecta un problema y continúa:
if invalid_count > 0:
print("Warning: invalid rows found")
Si no se debe confiar en el resultado, falla de forma explícita:
if invalid_count > 0:
raise ValueError(
f"Validation failed: {invalid_count} invalid records found."
)Así la capa de orquestación puede detectar el fallo.
Paso 16: pensar en la seguridad de los reintentos
Si un pipeline reintenta tu notebook, ¿qué ocurre?
Un notebook de producción no debe duplicar datos porque el primer intento escribió correctamente antes de que fallara la actividad.
Los patrones habituales incluyen:
- claves de negocio estables;
MERGEde Delta;- reemplazo de particiones;
- append idempotente;
- seguimiento de archivos procesados;
- estado de watermark/checkpoint.
El principio es:
Un reintento del pipeline no debe corromper el destino.
Paso 17: poner el notebook bajo control de versiones
Los notebooks de Fabric admiten la integración con Git como parte de la gestión del ciclo de vida de Fabric.
El control de versiones te aporta:
- historial de versiones;
- ramas;
- revisión de código;
- visibilidad de los cambios;
- un camino de promoción entre entornos.
Un modelo más sano que editar directamente en producción es:
- Cambio del desarrollador
- Rama de Git
- Revisión
- DEV
- validaciónTEST / QA
- PROD
Tu mecanismo de despliegue concreto puede usar la integración de Git de Fabric, las canalizaciones de implementación o CI/CD sobre las APIs de Fabric.
Paso 18: separar el código de la configuración del entorno
Un notebook que contiene en sus celdas IDs de workspace, IDs de Lakehouse, endpoints de producción o secretos se vuelve difícil de promover.
Prefiere una configuración específica de cada entorno fuera de la lógica de transformación principal.
Esto es especialmente importante al mover notebooks entre:
DEV
QA
PROD
Paso 19: entender qué despliega Git y qué no
El control de versiones y el despliegue gestionan los metadatos y el código de los elementos compatibles, no tus datos de negocio en sí.
Una separación útil es:
Git
→ definiciones / código / metadatos
OneLake
→ datos reales
Trata la migración de datos y el despliegue de la aplicación como asuntos relacionados pero separados.
Paso 20: monitorear la ejecución del notebook
Un notebook no está terminado porque haya funcionado una vez.
Haz seguimiento, como mínimo, de:
- la duración;
- el éxito o el fallo;
- el número de filas;
- el tamaño de la entrada;
- el tamaño de la salida;
- los reintentos;
- los registros rechazados;
- las ralentizaciones repetidas.
Un notebook que normalmente termina en 4 minutos y de repente tarda 25 puede seguir funcionando técnicamente, pero desde el punto de vista operativo merece una investigación.
Paso 21: fundamentos de rendimiento
Empieza por:
¿En qué se va realmente el tiempo?
Las posibilidades incluyen:
inicio de la sesión de Spark
lectura de datos
shuffle
join
serialización
escritura
archivos pequeños
latencia de la fuente
espera de orquestación
No optimices la sintaxis de Python cuando la carga pasa la mayor parte del tiempo redistribuyendo datos en Spark.
Evitar acciones innecesarias
Las acciones desencadenan la ejecución:
df.count()
display(df)
df.collect()Úsalas de forma deliberada.
Evitar grandes recolecciones en el driver
rows = df.collect()
puede saturar el driver con dataframes grandes.
Vigilar los joins
Antes de unir conjuntos de datos grandes, entiende:
- el número de filas;
- la cardinalidad de las claves;
- el sesgo (skew);
- las claves duplicadas;
- la cardinalidad de salida esperada.
Paso 22: mantener celdas adecuadas para producción
Una buena estructura es:
1. Parámetros
2. Imports
3. Configuración
4. Contexto de ejecución / registro
5. Lectura
6. Validación de la entrada
7. Transformación
8. Validación de la salida
9. Escritura
10. Métricas finales
La ejecución en producción no debe depender de ejecutar celdas manualmente en un orden oculto.
Paso 23: evitar el estado oculto del notebook
Un notebook puede parecer que funciona porque una variable se creó en una celda ejecutada antes.
Antes de considerarlo listo, prueba:
sesión nueva
→ Ejecutar todo
→ éxito
Si eso falla, el notebook todavía no es reproducible.
Paso 24: tratar el notebook como un componente
Un único notebook no tiene por qué encargarse de la ingesta, todas las transformaciones, la orquestación, el registro, las notificaciones y el serving.
Un límite más limpio podría ser:
Pipeline
├── Copiar los datos sin procesar
├── Notebook: validar + estandarizar
├── Notebook: transformación de negocio
├── Actividad de calidad de datos
└── Publicar / notificar
El límite debe reflejar las responsabilidades operativas.
Lista de comprobación para producción
Datos
- ¿Es explícito el contrato de entrada?
- ¿Se validan las claves importantes?
- ¿Se gestionan los duplicados?
- ¿Se contabilizan los registros no válidos?
Repetibilidad
- ¿Se ejecuta desde una sesión nueva?
- ¿Es seguro reintentarlo?
- ¿Son idempotentes las escrituras?
Configuración
- ¿Están externalizados los valores específicos del entorno?
- ¿Los valores de ejecución son parámetros en lugar de valores fijos?
Operaciones
- ¿Tiene cada ejecución una identidad?
- ¿Se registran el inicio, el fin y el estado?
- ¿Se capturan los recuentos de filas?
- ¿Un problema crítico de validación hace fallar la actividad?
Rendimiento
- ¿Se han revisado los joins grandes?
- ¿Se han eliminado las acciones de Spark innecesarias?
- ¿Se evita la recolección en el driver?
- ¿Es adecuada la estrategia de escritura?
Ciclo de vida
- ¿Está el notebook bajo control de versiones?
- ¿Puede pasar por DEV/TEST/PROD?
- ¿Se conocen los Lakehouses y entornos de los que depende?
Del primer notebook a producción
- 1El notebook funciona en modo interactivo
- 2El notebook se ejecuta desde una sesión limpia
- 3Se validan las entradas y las salidas
- 4Los parámetros sustituyen a los valores fijos
- 5Las escrituras son seguras ante reintentos
- 6El pipeline se encarga de la orquestación
- 7La ejecución queda registrada
- 8Git se encarga del historial de cambios
- 9El despliegue promueve entre entornos
- 10El monitoreo en producción mide el comportamiento
Esa es la diferencia entre usar un notebook y diseñar una carga de trabajo basada en notebooks.
Reflexiones finales
Microsoft Fabric facilita crear un notebook, conectarlo a un Lakehouse y empezar a transformar datos.
Pero el trabajo de ingeniería empieza después de la primera ejecución correcta.
Un notebook de producción necesita dependencias claras, parámetros, validación, escrituras seguras ante reintentos, registro de ejecución, control de versiones, disciplina de despliegue y monitoreo.
El objetivo no es eliminar la flexibilidad que hace útiles a los notebooks.
El objetivo es conservar esa flexibilidad y añadir la estructura suficiente para que el notebook sea confiable en producción.
Referencias oficiales de Microsoft
- Desarrollar, ejecutar y administrar notebooks de Fabric: https://learn.microsoft.com/en-us/fabric/data-engineering/author-execute-notebook
- Explorar los datos de un Lakehouse con un notebook: https://learn.microsoft.com/fabric/data-engineering/lakehouse-notebook-explore
- Cargar datos en un Lakehouse con un notebook: https://learn.microsoft.com/en-us/fabric/data-engineering/lakehouse-notebook-load-data
- Tutorial de Lakehouse: https://learn.microsoft.com/en-us/fabric/data-engineering/tutorial-build-lakehouse
- Actividad Notebook en Fabric Data Factory: https://learn.microsoft.com/en-us/fabric/data-factory/notebook-activity
- Control de código fuente e implementación de notebooks: https://learn.microsoft.com/en-us/fabric/data-engineering/notebook-source-control-deployment
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaMonitorear pipelines y notebooks de FabricMonitorea pipelines y notebooks de Microsoft Fabric con Monitoring hub, Workspace Monitoring, el monitoreo de Spark, KQL, alertas y telemetría de capacidad para que los errores y las regresiones de rendimiento sean observables.Abrir guía rápida
- RecursoContenido en inglésFabric Notebook Performance ChecklistA practical pre-run, read, transform, write and orchestration checklist for faster and more reliable Microsoft Fabric notebooks.Ver recurso
¿Qué debería crear después?
Estoy construyendo Javi Builds alrededor de problemas reales que enfrentan los ingenieros de datos. Dime qué tema te gustaría ver después.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.