Condividi tramite

Gestione delle sessioni NotebookUtils per Fabric

Usare notebookutils.session per gestire il ciclo di vita delle sessioni di notebook in Microsoft Fabric. È possibile arrestare una sessione interattiva o riavviare l'interprete Python per la pulizia, la gestione delle risorse e il ripristino degli errori.

Nella tabella seguente sono elencati i metodi di gestione delle sessioni disponibili:

metodo Firma Descrizione
stop stop(): void Arresta la sessione interattiva corrente in modo asincrono e rilascia le risorse. Nei notebook di PySpark, Scala e R, accettano un parametro facoltativo detach.
restartPython restartPython(): void Riavvia l'interprete Python mantenendo intatto il contesto Spark. Disponibile solo nei notebook Python e PySpark.

Annotazioni

Il stop() metodo è disponibile nei notebook Python, PySpark, Scala e R. Nei notebook PySpark, Scala e R, stop() accettano un parametro facoltativo detach: stop(detach=True). Quando detach è True (impostazione predefinita), la sessione si disconnette da una sessione di concorrenza elevata invece di arrestarla completamente.

Annotazioni

Il restartPython() metodo è disponibile solo nei notebook Python e PySpark. Non è disponibile nei notebook Scala o R.

Importante

In modalità di esecuzione della pipeline, le sessioni si arrestano automaticamente al termine del codice. L'API session.stop() è destinata principalmente alle sessioni interattive in cui si vuole arrestare la sessione a livello di codice anziché fare clic sul pulsante di arresto.

Annotazioni

Il stop() metodo opera in modo asincrono in background e rilascia le risorse della sessione Spark in modo che diventino disponibili per altre sessioni nello stesso pool.

Terminare una sessione interattiva

Invece di selezionare manualmente il pulsante di arresto, è possibile arrestare una sessione interattiva chiamando un'API nel codice.

notebookutils.session.stop()

L'API notebookutils.session.stop() ferma la sessione interattiva corrente in modo asincrono in background. Arresta anche la sessione Spark e rilascia le risorse occupate dalla sessione, in modo che siano disponibili per altre sessioni nello stesso pool.

Annotazioni

Il codice dopo session.stop() non viene eseguito. Tutti i dati e le variabili in memoria vengono persi dopo l'arresto della sessione. Salvare dati importanti prima di chiamare session.stop().

Comportamento di ritorno

Il stop() metodo non restituisce un valore. Avvia un arresto asincrono della sessione.

Riavviare l'interprete Python

Usare notebookutils.session.restartPython() per riavviare l'interprete Python.

Annotazioni

Nei notebook di PySpark (Spark), restartPython() riavvia solo l'interprete Python mantenendo intatto il contesto Spark. Nei notebook Python, che non hanno un contesto Spark, restartPython() riavvia l'intero processo Python.

notebookutils.session.restartPython()

Comportamento di ritorno

Il restartPython() metodo non restituisce un valore. Al termine del riavvio, l'esecuzione del codice continua nella cella successiva.

Tenere presenti queste considerazioni:

  • Nel caso di esecuzione del riferimento al notebook, restartPython() riavvia solo l'interprete Python del notebook corrente a cui si fa riferimento. Non influisce sul notebook principale.
  • In rari casi, il comando potrebbe non riuscire a causa del meccanismo di reflection di Spark. L'aggiunta di un nuovo tentativo può attenuare il problema.
  • Dopo aver chiamato restartPython(), l'esecuzione del codice continua nella cella successiva. Importare i pacchetti appena installati in una cella successiva.

Modelli di utilizzo

Pulizia normale prima dell'arresto

Usare un blocco try-finally per garantire l'esecuzione della pulizia prima dell'arresto della sessione.

try:
    print("Starting data processing...")
    # ... processing logic here ...

except Exception as e:
    print(f"Processing failed: {str(e)}")
    raise

finally:
    print("Performing cleanup...")
    try:
        notebookutils.fs.unmount("/mnt/data")
    except:
        pass

    notebookutils.session.stop()

Installare i pacchetti e riavviare l'interprete

Dopo aver installato nuovi pacchetti con pip, riavviare l'interprete Python in modo che i pacchetti siano disponibili:

import subprocess
import sys

packages = ["pandas==2.0.0", "numpy==1.24.0"]

print("Installing packages...")
for package in packages:
    subprocess.check_call([sys.executable, "-m", "pip", "install", package])

print("Restarting Python interpreter...")
notebookutils.session.restartPython()

Annotazioni

Dopo aver chiamato restartPython(), l'esecuzione del codice continua nella cella successiva. Importare i pacchetti appena installati in una cella successiva.

Ripristino degli errori con riavvio dell'interprete

Se l'interprete Python raggiunge uno stato danneggiato, è possibile tentare il ripristino riavviandolo:

def recover_from_error():
    """Attempt to recover from errors by restarting Python."""

    try:
        test_value = 1 + 1
    except Exception as e:
        print(f"Python interpreter error: {str(e)}")
        print("Restarting Python interpreter...")
        notebookutils.session.restartPython()
        return False

    return True

if not recover_from_error():
    print("Recovery attempted - check next cell")

Pulizia delle risorse prima dell'arresto

Pulire i percorsi montati, i file temporanei e le cache prima di terminare la sessione:

try:
    df = spark.range(0, 1000000)
    df.cache()
    result = df.count()
    print(f"Processing completed: {result}")

except Exception as e:
    print(f"Operation failed: {str(e)}")
    raise

finally:
    spark.catalog.clearCache()
    print("Stopping session to free resources...")
    notebookutils.session.stop()

Arresto condizionale solo per la modalità interattiva

Controllare il contesto di esecuzione prima dell'arresto per evitare chiamate non necessarie in modalità pipeline:

context = notebookutils.runtime.context

if not context['isForPipeline']:
    print("Interactive mode: stopping session...")
    notebookutils.session.stop()
else:
    print("Pipeline mode: session stops automatically after execution")

Suggerimento

Salvare sempre i risultati importanti, ad esempio la scrittura di DataFrames su un archivio o l'output di registrazione, prima di chiamare session.stop() o session.restartPython(). Entrambe le operazioni eliminano tutto lo stato in memoria.

Contenuti correlati

  • Last updated on