Conoscere il Notebook di Databricks: guida completa

Databricks è una piattaforma unificata di analisi che consente di integrare data engineering, machine learning e business analytics. Al centro di questo ecosistema ci sono i Notebook di Databricks, spazi di lavoro interattivi pensati per l’esplorazione dei dati, lo sviluppo di modelli e i workflow di produzione.

In questo articolo ti mostrerò come iniziare con i Notebook di Databricks. Se parti da zero, potresti voler cominciare iscrivendoti al nostro corso Introduction to Databricks per capire a fondo Databricks e come modernizza l’architettura dei dati. Il nostro corso è molto completo e copre tanti argomenti, tra cui la gestione del catalogo e l’ingestione dei dati: provalo.

Cosa sono i Notebook di Databricks?

I Notebook di Databricks sono spazi di lavoro interattivi basati sul cloud che permettono agli utenti di svolgere esplorazione dei dati, engineering, machine learning e analytics in un ambiente collaborativo. Usano un modello di esecuzione a celle, in cui è possibile scrivere ed eseguire codice in blocchi discreti.

Lingue supportate

I Notebook di Databricks supportano più linguaggi: puoi non solo scegliere il tuo linguaggio preferito, ma anche passare da una lingua all’altra nello stesso notebook. I linguaggi includono Python, SQL, Scala e R, per i quali offriamo corsi introduttivi.

Per facilitare l’interoperabilità multi‑linguaggio, Databricks mette a disposizione le cosiddette magic command:

• %python: esegue una cella usando Python.

• %sql: esegue query SQL.

• %scala: esegue comandi basati su Scala.

• %r: esegue codice R.

Funzionalità principali

I Notebook di Databricks vanno oltre i tradizionali ambienti di coding offrendo queste capacità chiave:

• Co‑authoring in tempo reale: più utenti possono modificare, eseguire e commentare i notebook contemporaneamente, favorendo una collaborazione fluida.
• Versioning automatico: la cronologia integrata consente di tracciare le modifiche, ripristinare revisioni e mantenere l’integrità del codice.
• Esecuzione interattiva: puoi eseguire singole celle o interi workflow, rendendo debugging e sviluppo iterativo più efficienti.
• Visualizzazioni integrate: supporto integrato per grafici, tabelle e dashboard senza librerie esterne.
• Integrazione con Git: il supporto nativo ai repository Git abilita il controllo versione, la condivisione del codice e workflow CI/CD.

Primi passi con i Notebook di Databricks

Leggere le funzionalità è un conto, vederle in azione è un altro. Il modo migliore per apprezzare Databricks è mettersi all’opera. In questa sezione ti aiuterò a creare, gestire e navigare i notebook nello spazio di lavoro Databricks. Vedrai da solo quanto può essere utile.

Creazione e gestione dei notebook

Nello spazio di lavoro Databricks puoi creare nuovi notebook o gestire quelli esistenti. Vediamo come.

Come creare un nuovo notebook nello spazio di lavoro Databricks

Per creare un nuovo notebook in Databricks:

• Vai al tuo Databricks Workspace.

Databricks Workspace. Immagine dell’autore.

• Clicca su Workspace > Create > Notebook.

Crea un Notebook Databricks. Immagine dell’autore.

• Assegna un nome, seleziona una lingua predefinita e collega un cluster.

Seleziona nome e lingua predefinita per il Notebook Databricks. Immagine dell’autore.

Importare notebook esistenti

Databricks consente di importare notebook da più fonti, come GitHub e repository Git, URL esterni o file locali caricati come file .dbc (archivio Databricks) o .ipynb (Jupyter).

Segui questi passaggi per importare notebook esistenti nel Databricks Workspace:

• Clicca Workspace > Import.

Importa un notebook esistente nel Databricks Workspace. Immagine dell’autore.

• Scegli la Source (URL, file o Git).

• Carica o fornisci il link al notebook.

Rinominare, organizzare e gestire gli accessi

Per rinominare un Notebook Databricks, clicca sul titolo del notebook e modifica il nome.

Puoi anche spostare i notebook in cartelle per una struttura migliore.

Spostare i Notebook Databricks in una cartella. Immagine dell’autore.

Prima di condividere il tuo Notebook Databricks, puoi gestire accessi e permessi per controllare chi può visualizzare, modificare o gestire il notebook.

Navigazione di base e panoramica UI

Prima di passare a esempi pratici sull’uso dei Notebook di Databricks, ti guido nell’interfaccia e nella navigazione della piattaforma.

Panoramica della toolbar, azioni sulle celle e barra laterale destra

La toolbar del Notebook Databricks offre accesso rapido alle seguenti azioni:

• Run: esegui singole celle o l’intero notebook. Ogni cella ha opzioni per:

• eseguire, modificare, eliminare o spostare la cella.

• cambiare il tipo di cella, ad esempio code, markdown, SQL o Scala.

• impostare magic command come %python o %sql.

Esecuzione di una cella in un Notebook Databricks. Immagine dell’autore.

• Clear State: reimposta variabili e stato di esecuzione.

Reimposta variabili e stato di esecuzione nel Notebook Databricks. Immagine dell’autore.

• View Mode: passa tra modalità modifica e presentazione.
• Comments: aggiungi feedback collaborativi su celle specifiche.

Commenti nel Notebook Databricks. Immagine dell’autore.

• Revisions: visualizza e ripristina versioni precedenti.

Cronologia versioni nel Notebook Databricks. Immagine dell’autore.

Nuovi miglioramenti dell’UI

Databricks ha introdotto diversi miglioramenti all’UI per un’esperienza più intuitiva. Con queste novità, i Notebook di Databricks offrono un ambiente di sviluppo ancora più snello e potente per i professionisti dei dati. Includono:

• Look & feel moderno: interfaccia più pulita e facile da usare.
• Editing Markdown migliorato: supporto avanzato per formattazione e integrazione di elementi visivi.
• Focus Mode: riduci le distrazioni nascondendo gli elementi dell’UI non necessari.
• Debug interattivo: nuovi strumenti per esecuzione step‑by‑step e tracciamento degli errori.

Pratica: scrivere ed eseguire codice

I Notebook di Databricks offrono un ambiente di coding interattivo in cui scrivere, eseguire e documentare il codice. In questa sezione tratto l’uso delle celle di codice, del Markdown e l’esecuzione efficiente del codice.

Celle di codice e Markdown

I Notebook di Databricks supportano più linguaggi, tra cui Python, SQL, Scala e R, all’interno dello stesso notebook.

Scrivere codice Python nel Notebook Databricks

Usa la magic command %python per scrivere codice Python in una cella del Notebook Databricks.

%python
import pandas as pd
# Load sample data and display the first few rows
df = spark.read.format("csv").option("header", "true").load("/databricks-datasets/airlines/part-00000")
pd_df = df.limit(5).toPandas()  # Convert to Pandas DataFrame
display(pd_df)  # Works in DatabricksOfferto da

Esempio di codice Python in un Notebook Databricks. Immagine dell’autore.

Scrivere codice SQL nel Notebook Databricks

Per scrivere codice SQL nel Notebook Databricks, usa la magic command %sql. Se hai impostato SQL come lingua predefinita del notebook, puoi eseguire la cella senza includere la magic command %sql.

-- Querying a dataset in SQL
SELECT origin, dest, COUNT(*) AS flight_count 
FROM flights_table 
GROUP BY origin, dest 
ORDER BY flight_count DESC 
LIMIT 10;Offerto da

Codice SQL in un Notebook Databricks. Immagine dell’autore.

Scrivere codice Scala nel Notebook Databricks

Usa la magic command %scala per scrivere codice Scala in una cella del Notebook Databricks.

%scala
// Reading and displaying data in Scala
val data = spark.read.option("header", "true").csv("/databricks-datasets/airlines/part-00000")

// Display as a table in Databricks
display(data)Offerto da

Codice Scala in un Notebook Databricks. Immagine dell’autore.

Scrivere codice R nel Notebook Databricks

Puoi anche scrivere codice R in una cella del Notebook Databricks usando la magic command %r.

%r
# Load a sample dataset in R
library(SparkR)
df <- read.df("/databricks-datasets/airlines/part-00000", source = "csv", header = "true")
head(df)Offerto da

Codice R in un Notebook Databricks. Immagine dell’autore.

Usare le celle Markdown per la documentazione

Le celle Markdown servono per aggiungere testo, intestazioni, elenchi e altra documentazione. L’esempio seguente mostra come scrivere una cella Markdown e come vengono visualizzati i risultati nel Notebook Databricks.

%md
# Data Exploration Notebook  
This notebook explores airline flight data, providing insights into flight frequency and destinations.  

## **Steps:**  
1. Load and display the dataset  
2. Query data using SQL  
3. Generate visualizationsOfferto da

Esecuzione delle celle

I Notebook di Databricks consentono un’esecuzione flessibile del codice tramite run di singole celle o in batch. 

Eseguire singole celle ed eseguire tutte le celle

Per eseguire una singola cella, clicca il pulsante Run (▶) nella cella o usa le scorciatoie da tastiera:

• Shift + Invio: esegue la cella corrente e passa alla successiva.
• Ctrl + Invio: esegue la cella senza passare alla successiva.

Per eseguire tutte le celle del notebook:

• Clicca Run All dalla toolbar.
• Il notebook verrà eseguito in sequenza dall’alto verso il basso.

Eseguire singole celle ed eseguire tutte le celle in un Notebook Databricks. Immagine dell’autore.

Visualizzazione degli output

I Notebook di Databricks supportano più formati di output, tra cui tabelle, grafici e log. Ad esempio, il codice Python seguente mostra le prime 5 righe del dataset ‘airlines’.

%python
import pandas as pd
# Load sample data and display the first few rows
df = spark.read.format("csv").option("header", "true").load("/databricks-datasets/airlines/part-00000")
# Displaying the first 5 rows of a DataFrame
display(df.limit(5))Offerto da

Visualizzare gli input nel Notebook Databricks. Immagine dell’autore.

Possiamo anche usare i Notebook di Databricks per visualizzare l’output delle celle. Per esempio, il codice Python qui sotto seleziona le 10 compagnie aeree più frequenti, converte i dati da PySpark a Pandas e usa Matplotlib per creare un grafico a barre.

%python
# Import necessary libraries
import matplotlib.pyplot as plt
import pandas as pd

# Load the dataset using PySpark
df = spark.read.option("header", "true").csv("/databricks-datasets/airlines/part-00000")

# Select the top 10 most frequent airlines (carrier column)
top_airlines = df.groupBy("UniqueCarrier").count().orderBy("count", ascending=False).limit(10)

# Convert PySpark DataFrame to Pandas DataFrame
pd_df = top_airlines.toPandas()

# Convert count column to integer (since it's a string in CSV)
pd_df["count"] = pd_df["count"].astype(int)

# Plot a bar chart
plt.figure(figsize=(10, 6))
plt.bar(pd_df["UniqueCarrier"], pd_df["count"], color="#ac4ce4")

# Add titles and labels
plt.xlabel("Airline Carrier", fontsize=12)
plt.ylabel("Flight Count", fontsize=12)
plt.title("Top 10 Most Frequent Airline Carriers", fontsize=14)
plt.xticks(rotation=45)  # Rotate x-axis labels for better readability

# Show the plot
plt.show()Offerto da

Visualizzare gli output in un Notebook Databricks. Immagine dell’autore.

Allo stesso modo, puoi mostrare più output dall’esecuzione di una singola cella nel Notebook Databricks. Ad esempio, l’output del codice seguente mostrerà le prime 5 righe del dataset airlines e il conteggio delle 10 compagnie aeree più frequenti.

%python
# Show the top 5 rows in an interactive table
display(df.limit(5))

# Show the top 10 most frequent airline carriers
top_carriers = df.groupBy("UniqueCarrier").count().orderBy("count", ascending=False).limit(10)
display(top_carriers)Offerto da

Visualizzare più output dall’esecuzione di una singola cella nel Notebook Databricks. Immagine dell’autore.

Funzionalità avanzate dei Notebook di Databricks

I Notebook di Databricks offrono potenti funzionalità di automazione, versioning e integrazione che migliorano produttività, collaborazione ed efficienza operativa. In questa sezione esploro le principali funzionalità avanzate e le best practice per sfruttare al massimo i Notebook di Databricks.

Automazione e pianificazione

Databricks permette di automatizzare l’esecuzione dei notebook pianificandoli come job e parametrizzando gli input per un’esecuzione dinamica.

Pianificare i notebook come job

Puoi pianificare i notebook a intervalli specifici, garantendo workflow automatizzati per ETL, reportistica e training dei modelli. Segui questi passaggi per pianificare un job di notebook:

• Apri il notebook e clicca Run as Job oppure vai alla scheda Jobs.
• Clicca Create Job e seleziona il notebook.

Creare una Job Run in un Notebook Databricks. Immagine dell’autore.

• Configura la pianificazione e imposta job giornalieri, orari o cron personalizzati.

Configurare pianificazioni e trigger in un Notebook Databricks. Immagine dell’autore.

• Collega un cluster e imposta dipendenze se necessario.
• Clicca Run Now per eseguire subito o lascialo eseguire secondo pianificazione.

Esecuzione delle Job Run in un Notebook Databricks. Immagine dell’autore.

Uso di parametri e widget per esecuzioni dinamiche

I widget di Databricks permettono di definire parametri dinamicamente, consentendo allo stesso notebook di girare con input diversi. Ad esempio, il widget dbutils.widgets.text() seguente crea un campo di testo interattivo etichettato "Enter Parameter" con valore predefinito default_value. Quindi recupera il valore inserito dall’utente e lo stampa.

dbutils.widgets.text("input_param", "default_value", "Enter Parameter")
param_value = dbutils.widgets.get("input_param")
print(f"User Input: {param_value}")Offerto da

Analogamente, il codice qui sotto genera un menu a discesa etichettato dataset con le opzioni sales, marketing e finance, impostando sales come predefinita. Recupera l’opzione selezionata e stampa il dataset scelto.

dbutils.widgets.dropdown("dataset", "sales", ["sales", "marketing", "finance"])
selected_dataset = dbutils.widgets.get("dataset")
print(f"Processing {selected_dataset} dataset")Offerto da

Versioning e collaborazione

Databricks offre funzionalità integrate di versioning e collaborazione, che semplificano il tracciamento delle modifiche, il ripristino delle versioni precedenti e il lavoro in team in tempo reale.

Cronologia versioni automatica e integrazione con Git

Ogni modifica in un Notebook Databricks viene versionata automaticamente. Per la cronologia versioni puoi:

• Visualizzare la cronologia versioni: clicca su Revision History per tracciare le modifiche.

Visualizzazione della cronologia versioni in un Notebook Databricks. Immagine dell’autore.

• Ripristinare versioni precedenti: torna a uno stato precedente se necessario.
• Usare l’integrazione con Git: sincronizza i notebook con GitHub, Azure DevOps o Bitbucket per il controllo versione.

Funzionalità di collaborazione in tempo reale

I Notebook di Databricks permettono ai team di co‑scrivere, commentare e condividere insight grazie a queste funzionalità:

• Co‑editing in tempo reale: più utenti possono modificare lo stesso notebook contemporaneamente.
• Commenti inline: aggiungi commenti su righe specifiche di codice per le discussioni.
• Condivisione e permessi: assegna ruoli come Viewer, Editor e Owner per controllare l’accesso.

Integrazione con altri strumenti

I Notebook di Databricks si integrano con Delta Live Tables, MLflow, SQL Warehouses e pipeline CI/CD per estenderne le funzionalità.

Usare Databricks con Delta Live Tables

Delta Live Tables (DLT) semplifica l’automazione delle pipeline dati con ETL dichiarativo. La query seguente crea una pipeline Delta Live Table in SQL.

-- Creating a live table called 'sales_cleaned' that stores cleaned data
CREATE LIVE TABLE sales_cleaned AS

    -- Selecting all columns where the 'order_status' is 'completed'
    SELECT * 
    FROM raw_sales
    WHERE order_status = 'completed'; Offerto da

MLflow per il tracciamento degli esperimenti

MLflow, integrato con Databricks, consente di tracciare gli esperimenti di machine learning. Ad esempio, il codice seguente registra in MLflow il learning rate e l’accuratezza di un modello come parte di un esperimento tracciato. Dopo la registrazione, termina la sessione dell’esperimento. Questo ti permette di tracciare iperparametri e performance nel tempo e confrontare run differenti.

# Import the MLflow library for experiment tracking
import mlflow
mlflow.start_run()
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)

mlflow.end_run()Offerto da

Esportazione dei Notebook e integrazione CI/CD

I Notebook di Databricks possono essere esportati in vari formati, tra cui:

• .html: condividi report in sola lettura.

• .ipynb: conversione in Jupyter Notebook.

• .dbc: archivio Databricks per portabilità.

Per esempio, puoi esportare un notebook via CLI con il seguente comando.

databricks workspace export /Users/my_notebook /local/path/my_notebook.ipynbOfferto da

Suggerimenti e trucchi per padroneggiare i Notebook di Databricks

I Notebook di Databricks offrono numerose funzionalità per snellire i workflow, aumentare la produttività e migliorare la collaborazione. In questa sezione ti mostro magic command, miglioramenti dell’UI, tecniche di esplorazione dei dati e strategie di gestione del codice che trovo utili quando lavoro sulla piattaforma dei Notebook di Databricks.

Magic command

Databricks fornisce magic command che semplificano varie attività, come eseguire script, gestire file e installare pacchetti.

%run

Per eseguire un altro notebook all’interno di quello corrente e modularizzare i workflow, puoi usare il comando %run. Puoi anche usare %run per suddividere grandi progetti in notebook riutilizzabili. Ad esempio, il comando seguente esegue il notebook data_preprocessing rendendo disponibili variabili, funzioni e output nel notebook corrente.

%run /Users/john.doe/notebooks/data_preprocessingOfferto da

%sh

Il comando %sh ti permette di eseguire comandi della shell Linux direttamente in un notebook. Nell’esempio sotto, il comando elenca il contenuto di /dbfs/data/ su DBFS.

%sh ls -lh /dbfs/data/Offerto da

%fs

Analogamente, il comando %fs consente di interagire con il Databricks File System (DBFS) per operazioni sui file. Ad esempio, il comando seguente elenca tutti i file e le directory in /databricks-datasets/, che contiene dataset pubblici forniti da Databricks.

%fs ls /databricks-datasets/Offerto da

Allo stesso modo, puoi usare %fs cp per copiare file, %fs rm per rimuoverli e %fs head per visualizzarne un’anteprima.

%pip

Il comando %pip installa pacchetti Python all’interno dell’ambiente del notebook. Il seguente comando installerà il pacchetto matplotlib nella sessione corrente del notebook.

%pip install pandas matplotlibOfferto da

Il comando %pip freeze viene utilizzato per elencare i pacchetti installati e garantire la riproducibilità.

Miglioramenti dell’UI

Databricks ha introdotto i seguenti miglioramenti dell’UI che migliorano navigazione, debugging ed esperienza d’uso complessiva:

• Nuova Results Table: migliore visualizzazione dei risultati delle query con tabelle ordinabili e filtrabili.
• Editor Markdown migliorato: formattazione avanzata, blocchi di codice e immagini incorporate.
• Debugger interattivo: esecuzione step‑through per risolvere script complessi.
• Inline Assistant (Databricks AI Assistant): completa automaticamente il codice, suggerisce correzioni e migliora l’efficienza.

Consiglio sempre di abilitare la Focus Mode (View → Focus Mode) per ridurre le distrazioni.

Tecniche di esplorazione dei dati

Databricks offre strumenti integrati per sfogliare dataset, comprenderne lo schema e fare profiling dei dati direttamente nei notebook.

Per sfogliare i dataset su DBFS, usa %fs ls o display(dbutils.fs.ls()) per ispezionare i dataset disponibili.

display(dbutils.fs.ls("/databricks-datasets/"))Offerto da

Puoi anche esplorare gli schemi delle tabelle direttamente dalla barra laterale dell’interfaccia seguendo questi passaggi:

• Clicca Data nello workspace.
• Sfoglia database e tabelle.
• Clicca su una tabella per vedere anteprima dati e schema.

Per il data profiling, puoi riassumere i dati usando display() o query SQL.

df.describe().show()Offerto da

%sql
SELECT COUNT(*), AVG(salary), MAX(age) FROM employees;Offerto da

Strategie di gestione del codice

Usa le seguenti tecniche per gestire il tuo codice nei Notebook di Databricks. Anzitutto, assicurati di archiviare snippet di codice riutilizzabili in notebook separati e richiamali con %run. Usa anche le Databricks Utilities (dbutils) per le trasformazioni. Inoltre, per la leggibilità è buona prassi seguire PEP 8 (Python) o le best practice SQL. Usa sempre celle markdown per i commenti.

-- Select customer_id and calculate total revenue per customer
SELECT customer_id, SUM(total_amount) AS revenue  
FROM sales_data  
-- Group results by customer to get total revenue per customer
GROUP BY customer_id  
-- Order customers by revenue in descending order (highest first)
ORDER BY revenue DESC  
-- Return only the top 10 customers by revenue
LIMIT 10;Offerto da

Se riscontri problemi lavorando con i Notebook di Databricks, puoi procedere al troubleshooting con i seguenti metodi:

• Cluster bloccato? Riavvia il kernel (Run → Clear State & Restart).

• Esecuzione lenta? Controlla la Spark UI (Cluster → Spark UI) per individuare colli di bottiglia.

• Conflitti di versione? Usa %pip list per verificare le dipendenze.

Usa queste scorciatoie da tastiera per scrivere più velocemente:

• Shift + Invio → esegui la cella corrente.
• Ctrl + / → commenta/decommenta le righe selezionate.
• Esc + A/B → aggiungi una nuova cella sopra/sotto.

Casi d’uso reali e scenari

I Notebook di Databricks sono ampiamente usati in data engineering, machine learning e business intelligence. In questa sezione evidenzio casi reali e snippet di codice per mostrare come i team sfruttano i Notebook di Databricks per workflow di produzione.

Case study 1: pipeline ETL per il data engineering

Considera uno scenario in cui un’azienda retail acquisisce dati di vendita grezzi, li pulisce e li archivia in Delta Lake per la reportistica. Il processo è il seguente:

• Step 1: leggere i dati grezzi dallo storage cloud.
• Step 2: pulire e trasformare i dati con PySpark.
• Step 3: archiviare i dati puliti in una Delta Table.
• Step 4: pianificare il notebook come job.

Questo processo migliora l’affidabilità dei dati e le performance delle query per la reportistica. Lo snippet di codice seguente è un esempio di implementazione della soluzione:

# Read raw sales data from cloud storage
df = spark.read.format("csv").option("header", "true").load("s3://sales-data/raw/")

# Data cleaning and transformation
df_cleaned = df.filter(df["status"] == "completed").dropDuplicates()

# Save to Delta Table for analysis
df_cleaned.write.format("delta").mode("overwrite").saveAsTable("sales_cleaned")Offerto da

Case study 2: sviluppo di modelli di machine learning

Considera un altro scenario in cui un istituto finanziario prevede i default sui prestiti con un modello di machine learning. Per implementare questo workflow nel Notebook Databricks, segui i passaggi sotto. Il risultato sarà il tracciamento e la distribuzione automatizzati del modello con MLflow.

• Step 1: caricare e preprocessare i dati dei prestiti.
• Step 2: addestrare un modello di regressione logistica usando MLflow.
• Step 3: registrare e tracciare il modello.

# import libraries
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import mlflow

# Load and prepare data
df = spark.read.table("loan_data").toPandas()
X_train, X_test, y_train, y_test = train_test_split(df.drop("default", axis=1), df["default"])

# Train model
model = LogisticRegression()
model.fit(X_train, y_train)

# Log model in MLflow
mlflow.sklearn.log_model(model, "loan_default_model")Offerto da

Case study 3: analisi ad hoc per la business intelligence

In uno scenario in cui un team marketing analizza le tendenze di engagement dei clienti, implementerai la soluzione nei passaggi seguenti:

• Step 1: interrogare con SQL i dati sul comportamento dei clienti.
• Step 2: generare visualizzazioni interattive.

Questo processo porta a decisioni più rapide con dashboard interattive.

%sql
-- Count the number of interactions per customer segment
SELECT customer_segment, COUNT(*) AS interactions  
FROM user_activity  
-- Group by customer segment to aggregate interaction counts
GROUP BY customer_segment  
-- Order results by interaction count in descending order
ORDER BY interactions DESC;Offerto da

Se vuoi ripassare Databricks SQL, ti consiglio di leggere il nostro tutorial Databricks SQL per imparare a configurare un SQL Warehouse dall’interfaccia web di Databricks.

Troubleshooting e FAQ

Quando esegui notebook Databricks in parallelo, il debugging e il mantenimento delle performance possono porre sfide specifiche. Ecco alcuni spunti per mantenere il tuo notebook privo di errori in ambienti di produzione.

Problemi comuni e soluzioni

Ecco alcuni problemi e le soluzioni consigliate:

• Un notebook che funziona bene singolarmente fallisce quando più utenti o job lo eseguono contemporaneamente: il problema potrebbe essere causato da variabili condivise. Inoltre, un singolo cluster potrebbe non supportare esecuzioni multiple. Per risolvere, usa widget per la parametrizzazione o abilita l’autoscaling del cluster per avere risorse sufficienti alle esecuzioni concorrenti.

• Un notebook che prima era veloce ora impiega molto più tempo: il problema può dipendere da trasformazioni Spark inefficienti che causano shuffle o da troppi dataset in cache/persist che consumano memoria. Per risolvere, gestisci le operazioni con .persist() e .unpersist(). Monitora anche la Spark UI per partizioni sbilanciate e ottimizza le query con tabelle Delta.

• %run fallisce quando prova a eseguire un altro notebook: può succedere se il percorso del notebook è errato o se il notebook referenziato dipende da un cluster non disponibile. Per risolvere, usa percorsi assoluti per gli import dei notebook o verifica la disponibilità del cluster per assicurarti che i notebook referenziati usino un cluster compatibile.

• Un job pianificato del notebook fallisce: può accadere se il cluster è stato terminato prima dell’esecuzione o se è fallita una dipendenza esterna, come una connessione a database o una chiamata API. Per risolvere, abilita il riavvio del cluster in caso di errore. Nelle impostazioni del job, abilita Retry on Failure. Usa anche blocchi Try‑Except per le chiamate esterne.

Leggi il nostro tutorial Mastering the Databricks API per imparare a usare le REST API di Databricks per la pianificazione dei job e il ridimensionamento di pipeline automatizzate.

Best practice per mantenere i notebook in produzione

Usa le seguenti tecniche per mantenere i Notebook di Databricks in produzione:

• Modularizza il codice in notebook riutilizzabili: suddividi i notebook grandi in unità più piccole e riutilizzabili e usali con %run. Archivia le funzioni helper in notebook di utilità separati.

• Usa il controllo versione (integrazione Git): abilita Databricks Repos per tracciare le modifiche e fare rollback delle versioni.

• Ottimizza la scelta del cluster per i job: usa job cluster anziché cluster interattivi per le esecuzioni pianificate.

• Implementa logging e avvisi: usa dbutils.notebook.exit() per registrare lo stato dei job. Puoi anche configurare avvisi email nella Jobs UI per notificare i team in caso di errori.

• Documenta il codice e usa Markdown per chiarezza: usa celle markdown per descrivere passaggi e logica del workflow.

Conclusione

Se vuoi esplorare i concetti fondamentali di Databricks, ti consiglio vivamente il nostro corso Introduction to Databricks. Questo corso ti dà le basi giuste per poi sperimentare funzionalità avanzate come magic command, parametrizzazione e ottimizzazioni delle performance. Infine, ti suggerisco anche di informarti su come ottenere una Databricks Certification. Il nostro post ti aiuta a esplorare i vantaggi per la carriera e a scegliere la certificazione più adatta ai tuoi obiettivi.