Administrer notatbokartefakter med NotebookUtils

Brukes notebookutils.notebook til å administrere notatbøker programmert i Microsoft Fabric. Du kan opprette, hente ut, oppdatere, slette og liste notatbokartefakter for å automatisere distribusjon, livssyklusstyring og CI/CD-arbeidsflyter.

Bemerkning

Disse API-ene støttes kun i Fabric-notatbøker, ikke i Azure Synapse. Du må ha passende tillatelser i målarbeidsområdet for hver operasjon.

Følgende tabell viser tilgjengelige metoder for notatbokhåndtering:

Metode	Signatur	Beskrivelse
`create`	`create(name, description, content, defaultLakehouse, defaultLakehouseWorkspace, workspaceId): Artifact`	Lager en ny notatbok.
`get`	`get(name, workspaceId): Artifact`	Henter en notatbok med navn eller ID.
`getDefinition`	`getDefinition(name, workspaceId, format): String`	Henter notatbokdefinisjonen (innholdet).
`update`	`update(name, newName, description, workspaceId): Artifact`	Oppdaterer notatbokmetadata.
`updateDefinition`	`updateDefinition(name, content, defaultLakehouse, defaultLakehouseWorkspace, workspaceId, environmentId, environmentWorkspaceId): bool`	Oppdaterer notatbokdefinisjonen og lakehouse.
`delete`	`delete(name, workspaceId): Boolean`	Sletter en notatblokk.
`list`	`list(workspaceId, maxResults): Array[Artifact]`	Lister opp alle notatbøker i et arbeidsområde.

Opprette en notatblokk

Bruk notebookutils.notebook.create() til å opprette en ny notatbok-artefakt i det nåværende arbeidsområdet eller et spesifisert arbeidsområde.

Bemerkning

Arbeidsflyteksempler i denne artikkelen som leser eller skriver .ipynb filer bruker Python for fil-I/O. Kjerne-API-ene notebookutils.notebook er tilgjengelige i Python, PySpark, Scala og R, med mindre annet er oppgitt.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Visningsnavn for den nye notatboken. Må være unik innenfor arbeidsområdet.
`description`	string	Nei	Beskrivelse av notatboken. Standardinnstillingen er tom.
`content`	Streng, bytes eller dict	Ja	Notatbokens innhold er i gyldig `.ipynb` JSON-format. Kan også være råbytes eller et dict-objekt. Kan ikke være tom.
`defaultLakehouse`	string	Nei	Navn eller ID på standard hytte ved innsjøen som skal festes.
`defaultLakehouseWorkspace`	string	Nei	Arbeidsområde-ID for standard lakehouse. La det stå tomt for det nåværende arbeidsområdet.
`workspaceId`	string	Nei	Mål-arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.

Viktig!

Parameteren content kan ikke være tom. Du må oppgi gyldig .ipynb innhold når du lager en notatbok. Minst oppgi en gyldig tom notatbokstruktur:

{
  "cells": [],
  "metadata": {},
  "nbformat": 4,
  "nbformat_minor": 5
}

Lag en notatbok fra en mal

# Read notebook template from a file
with open("/path/to/template.ipynb", "r") as f:
    notebook_content = f.read()

# Create the notebook
notebook = notebookutils.notebook.create(
    name="ProcessingNotebook",
    description="Data processing notebook from template",
    content=notebook_content
)

print(f"Created notebook: {notebook.displayName} (ID: {notebook.id})")

Lag en notatbok med standard innsjøhus

# Minimum valid notebook content - content cannot be empty
minimal_content = '''{
    "cells": [],
    "metadata": {},
    "nbformat": 4,
    "nbformat_minor": 5
}'''

# Create notebook with default lakehouse configuration
notebook = notebookutils.notebook.create(
    name="DataAnalysis",
    description="Analysis notebook with lakehouse access",
    content=minimal_content,
    defaultLakehouse="MyLakehouse",
    defaultLakehouseWorkspace=""  # Current workspace
)

print(f"Created notebook with lakehouse: {notebook.displayName}")

val minimalContent = """{
    "cells": [],
    "metadata": {},
    "nbformat": 4,
    "nbformat_minor": 5
}"""

val notebook = notebookutils.notebook.create(
    "DataAnalysis",
    "Analysis notebook with lakehouse access",
    minimalContent,
    "MyLakehouse",
    "",
    ""
)

println(s"Created notebook with lakehouse: ${notebook.displayName}")

minimal_content <- '{
    "cells": [],
    "metadata": {},
    "nbformat": 4,
    "nbformat_minor": 5
}'

notebook <- notebookutils.notebook.create(
    "DataAnalysis",
    "Analysis notebook with lakehouse access",
    minimal_content,
    "MyLakehouse",
    "",
    ""
)

print(paste("Created notebook with lakehouse:", notebook$displayName))

Returverdi

Metoden create() returnerer et Artifact objekt med følgende egenskaper:

displayName: Notatbokens visningsnavn.
id: Den unike identifikatoren til den opprettede notatboken.
description: Beskrivelsen av notatboken.

Opprett en notatbok i et annet arbeidsområde

with open("/path/to/notebook.ipynb", "r") as f:
    content = f.read()

notebook = notebookutils.notebook.create(
    name="SharedNotebook",
    description="Notebook for the shared workspace",
    content=content,
    workspaceId="bbbbbbbb-2222-3333-4444-cccccccccccc"
)

print(f"Created in remote workspace: {notebook.displayName}")

Lag flere notatbøker fra en mal

# Load template content (must be valid .ipynb)
with open("/path/to/template.ipynb", "r") as f:
    template_content = f.read()

regions = ["US", "EU", "Asia"]

created_notebooks = []
for region in regions:
    notebook = notebookutils.notebook.create(
        name=f"Process_{region}",
        description=f"Processing notebook for {region} region",
        content=template_content,
        defaultLakehouse=f"Lakehouse_{region}"
    )
    created_notebooks.append(notebook)
    print(f"Created: {notebook.displayName}")

print(f"\nCreated {len(created_notebooks)} notebooks")

Tips

Gi meningsfulle navn og beskrivelser til notatbøkene dine for å gjøre dem lettere å finne. Bruk en konsistent navnekonvensjon, som <Project>_<Purpose>_<Region> for automatiserte distribusjoner.

Skaff deg en notatbok

Bruk notebookutils.notebook.get() for å hente notatbokmetadata etter navn eller ID. Den returnerer et Artifact objekt med egenskaper som displayName, id, og description.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Navn eller ID på notatboken som skal hentes.
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.

Hent en notatbok fra det nåværende arbeidsområdet

notebook = notebookutils.notebook.get("MyNotebook")

print(f"Notebook Name: {notebook.displayName}")
print(f"Notebook ID: {notebook.id}")
print(f"Description: {notebook.description}")

val notebook = notebookutils.notebook.get("MyNotebook")

println(s"Notebook Name: ${notebook.displayName}")
println(s"Notebook ID: ${notebook.id}")
println(s"Description: ${notebook.description}")

notebook <- notebookutils.notebook.get("MyNotebook")

print(paste("Notebook Name:", notebook$displayName))
print(paste("Notebook ID:", notebook$id))
print(paste("Description:", notebook$description))

Hent en notatbok fra et annet arbeidsområde

workspace_id = "bbbbbbbb-2222-3333-4444-cccccccccccc"
notebook = notebookutils.notebook.get("SharedNotebook", workspaceId=workspace_id)

print(f"Retrieved: {notebook.displayName} from workspace {workspace_id}")

Returverdi

Metoden get() returnerer et Artifact objekt med følgende egenskaper:

displayName: Notatbokens visningsnavn.
id: Den unike identifikatoren.
description: Beskrivelsen av notatboken.

Tips

Bruk get() før oppdatering eller sletting for å verifisere at målnotatboken eksisterer. Du kan også bruke det til å sjekke om et notatboknavn allerede er i bruk før du oppretter et nytt.

Få en notatbokdefinisjon

Bruk notebookutils.notebook.getDefinition() den for å hente ut hele notatboken i .ipynb format. Bruk det til sikkerhetskopiering, migrering, versjonskontroll eller innholdsanalyse.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Navn eller ID på notatboken.
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.
`format`	string	Nei	Utdataformat. Standarder til `"ipynb"`.

Hent og lagre en notatbokdefinisjon

# Retrieve notebook definition as .ipynb content
notebook_content = notebookutils.notebook.getDefinition("MyNotebook")

# Save to a file for backup
with open("/path/to/backup/MyNotebook.ipynb", "w") as f:
    f.write(notebook_content)

print("Notebook definition retrieved and saved")

// Retrieve notebook definition in Scala
val content = notebookutils.notebook.getDefinition("MyNotebook")

println(s"Retrieved notebook content (${content.length} characters)")

content <- notebookutils.notebook.getDefinition("MyNotebook")

print(paste("Retrieved notebook content (", nchar(content), " characters)", sep = ""))

Få en notatbokdefinisjon fra et annet arbeidsområde

workspace_id = "cccccccc-3333-4444-5555-dddddddddddd"
notebook_content = notebookutils.notebook.getDefinition(
    name="SharedNotebook",
    workspaceId=workspace_id,
    format="ipynb"
)

print(f"Retrieved definition from workspace {workspace_id}")

Returverdi

Metoden getDefinition() returnerer en streng som inneholder notatbokens innhold i .ipynb JSON-format.

Eksporter alle notatbøker for sikkerhetskopiering

import os
from datetime import datetime

def export_all_notebooks(backup_dir="/path/to/backups"):
    """Export all notebooks in the workspace for backup."""

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    export_dir = f"{backup_dir}/backup_{timestamp}"
    os.makedirs(export_dir, exist_ok=True)

    notebooks = notebookutils.notebook.list()
    print(f"Exporting {len(notebooks)} notebooks to {export_dir}")

    exported_count = 0
    for nb in notebooks:
        try:
            content = notebookutils.notebook.getDefinition(nb.displayName)
            filename = f"{export_dir}/{nb.displayName}.ipynb"
            with open(filename, "w") as f:
                f.write(content)
            exported_count += 1
            print(f"Exported: {nb.displayName}")
        except Exception as e:
            print(f"Failed to export {nb.displayName}: {e}")

    print(f"\nExported {exported_count} of {len(notebooks)} notebooks")
    return export_dir

backup_location = export_all_notebooks()

Oppdater en notatbok

Bruk notebookutils.notebook.update() for å endre notatbokens metadata, som visningsnavn og beskrivelse. Den endrer ikke notatbokinnholdet eller lakehouse-konfigurasjonen.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Nåværende navn eller ID på notatboken.
`newName`	string	Ja	Nytt visningsnavn for notatboken.
`description`	string	Nei	Oppdatert beskrivelse.
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.

Gi nytt navn til en notatbok

updated_notebook = notebookutils.notebook.update(
    name="OldNotebookName",
    newName="NewNotebookName",
    description="Updated description with more details"
)

print(f"Updated notebook: {updated_notebook.displayName}")

Returverdi

Metoden update() returnerer et Artifact objekt med de oppdaterte egenskapene.

Oppdater en notatbokdefinisjon

Bruk notebookutils.notebook.updateDefinition() den til å endre notatbokinnhold, standard lakehouse, eller begge deler. Bruk det når du må endre notatbokdefinisjonen i stedet for metadataene.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Navn eller ID på notatboken som skal oppdateres.
`content`	string	Nei	Nytt notatbok-innhold i `.ipynb` format.
`defaultLakehouse`	string	Nei	Nytt standard innsjøhusnavn.
`defaultLakehouseWorkspace`	string	Nei	Arbeidsområde-ID for det nye standard innsjøhuset. La det stå tomt for det nåværende arbeidsområdet.
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.
`environmentId`	string	Nei	Miljø-ID for å knytte til notatboken.
`environmentWorkspaceId`	string	Nei	Arbeidsområde-ID for miljøet. La det stå tomt for det nåværende arbeidsområdet.

Bemerkning

Og-parameterne environmentIdenvironmentWorkspaceId er kun tilgjengelige i Spark-notebookens runtime. Python-notatbøker støtter ikke disse parameterne.

Oppdater innholdet i notatboken

# Load new content
with open("/path/to/updated_notebook.ipynb", "r") as f:
    new_content = f.read()

is_updated = notebookutils.notebook.updateDefinition(
    name="MyNotebook",
    content=new_content
)

print(f"Notebook definition updated: {is_updated}")

val newContent = """{
    "cells": [],
    "metadata": {},
    "nbformat": 4,
    "nbformat_minor": 5
}"""

val isUpdated = notebookutils.notebook.updateDefinition(
    "MyNotebook",
    newContent
)

println(s"Notebook definition updated: ${isUpdated}")

new_content <- '{
    "cells": [],
    "metadata": {},
    "nbformat": 4,
    "nbformat_minor": 5
}'

is_updated <- notebookutils.notebook.updateDefinition(
    "MyNotebook",
    new_content
)

print(paste("Notebook definition updated:", is_updated))

Endre standard innsjøhus

is_updated = notebookutils.notebook.updateDefinition(
    name="MyNotebook",
    defaultLakehouse="NewLakehouse",
    defaultLakehouseWorkspace=""  # Current workspace
)

print(f"Default lakehouse updated: {is_updated}")

Oppdater både innholdet og lakehouse

with open("/path/to/new_version.ipynb", "r") as f:
    new_content = f.read()

is_updated = notebookutils.notebook.updateDefinition(
    name="MyNotebook",
    content=new_content,
    defaultLakehouse="ProductionLakehouse",
    defaultLakehouseWorkspace=""
)

print(f"Notebook fully updated: {is_updated}")

Returverdi

Metoden updateDefinition() returnerer True hvis oppdateringen lykkes eller False feiler.

Tips

Bruk update() for metadataendringer (navn, beskrivelse) og updateDefinition() for innholds- og lakehouse-endringer. Når du trenger en full oppdatering av både metadata og innhold, kall begge metodene i rekkefølge.

Slette en notatblokk

Bruk notebookutils.notebook.delete() for å permanent fjerne en notatbok fra et arbeidsområde. Den returnerer True hvis slettingen lykkes; ellers returnerer Falseden .

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`name`	string	Ja	Navn eller ID på notatboken som skal slettes.
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.

Viktig!

Sletting er permanent. Slettede notatbøker kan ikke gjenopprettes. Verifiser alltid notatbokens navn før du sletter, og vurder å ta backup av notatbokdefinisjonen først getDefinition() .

Returverdi

Metoden delete() returnerer True hvis slettingen lykkes eller False mislykkes.

Slette en notatblokk

is_deleted = notebookutils.notebook.delete("ObsoleteNotebook")

if is_deleted:
    print("Notebook deleted successfully")
else:
    print("Failed to delete notebook")

// Delete a notebook in Scala
val isDeleted = notebookutils.notebook.delete("ObsoleteNotebook")

if (isDeleted) println("Deleted") else println("Failed to delete")

is_deleted <- notebookutils.notebook.delete("ObsoleteNotebook")

if (is_deleted) {
    print("Notebook deleted successfully")
} else {
    print("Failed to delete notebook")
}

Rydd opp i notatbøker trygt etter mønster

def cleanup_notebooks(name_pattern, dry_run=True):
    """Delete notebooks matching a name pattern."""

    notebooks = notebookutils.notebook.list()
    to_delete = [nb for nb in notebooks if name_pattern in nb.displayName]

    print(f"Found {len(to_delete)} notebooks matching '{name_pattern}':")
    for nb in to_delete:
        print(f"  - {nb.displayName}")

    if dry_run:
        print("\nDRY RUN - No notebooks deleted")
        return

    deleted_count = 0
    for nb in to_delete:
        if notebookutils.notebook.delete(nb.displayName):
            deleted_count += 1
            print(f"Deleted: {nb.displayName}")
        else:
            print(f"Failed to delete: {nb.displayName}")

    print(f"\nDeleted {deleted_count} of {len(to_delete)} notebooks")

# Always run with dry_run=True first to preview
cleanup_notebooks("temp_", dry_run=True)

Tips

For sikker massesletting, kjør alltid med dry_run=True først for å forhåndsvise hvilke notatbøker som vil bli fjernet. Vurder å gi notatbøker nytt navn med et _TO_DELETE prefiks i stedet for å slette dem med en gang, slik at du kan gjenopprette dem om nødvendig.

Liste notatbøker

Bruk notebookutils.notebook.list() den til å liste opp notatbøker i et arbeidsområde. Den returnerer et array av Artifact objekter.

Parametere

Parameter	Type	Påkrevd	Beskrivelse
`workspaceId`	string	Nei	Arbeidsområde-ID. La det stå tomt for det nåværende arbeidsområdet.
`maxResults`	Int	Nei	Maksimalt antall resultater å returnere. Standard er 1000.

List opp alle notatbøker i det nåværende arbeidsområdet

notebooks = notebookutils.notebook.list()

print(f"Found {len(notebooks)} notebooks:")
for nb in notebooks:
    print(f"  - {nb.displayName} (ID: {nb.id})")

// List all notebooks in Scala
val notebooks = notebookutils.notebook.list()

println(s"Found ${notebooks.length} notebooks")
notebooks.foreach(nb => println(s"  - ${nb.displayName}"))

notebooks <- notebookutils.notebook.list()

print(paste("Found", length(notebooks), "notebooks:"))
for (nb in notebooks) {
    print(paste(" -", nb$displayName, "(ID:", nb$id, ")"))
}

List notatbøker i et annet arbeidsområde

workspace_id = "cccccccc-3333-4444-5555-dddddddddddd"
notebooks = notebookutils.notebook.list(workspaceId=workspace_id)

print(f"Found {len(notebooks)} notebooks in workspace {workspace_id}")

Returverdi

Metoden list() returnerer et array av Artifact objekter. Hvert objekt inneholder displayName, id, og description egenskaper.

Filtrer notatbøker etter navnemønster

all_notebooks = notebookutils.notebook.list()

# Filter for notebooks that start with a specific prefix
processing_notebooks = [nb for nb in all_notebooks if nb.displayName.startswith("Process_")]

print(f"Found {len(processing_notebooks)} processing notebooks:")
for nb in processing_notebooks:
    print(f"  - {nb.displayName}")

Klon en notatbok

Bruk list() og getDefinition() sammen for å klone en notatbok innenfor samme arbeidsområde eller til et annet arbeidsområde.

def clone_notebook(source_name, target_name, target_workspace=""):
    """Clone a notebook by retrieving its content and creating a copy."""

    source = notebookutils.notebook.get(source_name)
    content = notebookutils.notebook.getDefinition(source_name)

    cloned = notebookutils.notebook.create(
        name=target_name,
        description=f"Clone of {source_name}",
        content=content,
        workspaceId=target_workspace
    )

    print(f"Cloned {source_name} to {cloned.displayName}")
    return cloned

cloned_notebook = clone_notebook("TemplateNotebook", "NewInstance")

Migrer en notatbok til et annet arbeidsområde

def migrate_notebook(name, target_workspace_id, new_name=None):
    """Migrate a notebook from the current workspace to another workspace."""

    content = notebookutils.notebook.getDefinition(name)
    target_name = new_name if new_name else name

    migrated = notebookutils.notebook.create(
        name=target_name,
        description=f"Migrated from {name}",
        content=content,
        workspaceId=target_workspace_id
    )

    print(f"Migrated {name} to workspace {target_workspace_id} as {target_name}")
    return migrated

target_ws = "dddddddd-4444-5555-6666-eeeeeeeeeeee"
migrated_nb = migrate_notebook("DataPipeline", target_ws, "DataPipeline_v2")

Tilbakemeldinger

Var denne siden nyttig?

Last updated on 2026-04-02

Del via

Administrer notatbokartefakter med NotebookUtils

Opprette en notatblokk

Parametere

Lag en notatbok fra en mal

Lag en notatbok med standard innsjøhus

Returverdi

Opprett en notatbok i et annet arbeidsområde

Lag flere notatbøker fra en mal

Skaff deg en notatbok

Parametere

Hent en notatbok fra det nåværende arbeidsområdet

Hent en notatbok fra et annet arbeidsområde

Returverdi

Få en notatbokdefinisjon

Parametere

Hent og lagre en notatbokdefinisjon

Få en notatbokdefinisjon fra et annet arbeidsområde

Returverdi

Eksporter alle notatbøker for sikkerhetskopiering

Oppdater en notatbok

Parametere

Gi nytt navn til en notatbok

Returverdi

Oppdater en notatbokdefinisjon

Parametere

Oppdater innholdet i notatboken

Endre standard innsjøhus

Oppdater både innholdet og lakehouse

Returverdi

Slette en notatblokk

Parametere

Returverdi

Slette en notatblokk

Rydd opp i notatbøker trygt etter mønster

Liste notatbøker

Parametere

List opp alle notatbøker i det nåværende arbeidsområdet

List notatbøker i et annet arbeidsområde

Returverdi

Filtrer notatbøker etter navnemønster

Klon en notatbok

Migrer en notatbok til et annet arbeidsområde

Relatert innhold

Tilbakemeldinger

Flere ressurser