NotebookUtils를 사용하여 Notebook 아티팩트 관리

Microsoft Fabric에서 프로그래밍 방식으로 전자 필기장 항목을 관리하는 데 사용합니다 notebookutils.notebook . Notebook 아티팩트 만들기, 검색, 업데이트, 삭제 및 나열하여 배포, 수명 주기 관리 및 CI/CD 워크플로를 자동화할 수 있습니다.

다음 표에서는 사용 가능한 Notebook 관리 방법을 나열합니다.

Notebook 만들기

현재 작업 영역 또는 지정된 작업 영역에서 새 Notebook 아티팩트를 만드는 데 사용합니다 notebookutils.notebook.create() .

매개 변수

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

템플릿에서 Notebook 만들기

# 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})")

기본 레이크하우스를 사용하여 Notebook 만들기

# 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))

반환 값

메서드는 create() 다음 속성을 가진 Artifact 개체를 반환합니다.

• displayName: 노트북의 표시 이름입니다.
• id: 만든 Notebook의 고유 식별자입니다.
• description: 노트북의 설명입니다.

다른 작업 영역에서 Notebook 만들기

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}")

템플릿에서 여러 Notebook 만들기

# 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")

노트북 가져오기

이름 또는 ID별로 Notebook 메타데이터를 검색하는 데 사용합니다 notebookutils.notebook.get() . Artifact, displayName, 및 id 같은 속성을 가진 개체description를 반환합니다.

매개 변수

현재 작업 영역에서 Notebook 가져오기

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))

다른 작업 영역에서 Notebook 가져오기

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

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

반환 값

메서드는 get() 다음 속성을 가진 Artifact 개체를 반환합니다.

• displayName: 노트북의 표시 이름입니다.
• id: 고유 식별자입니다.
• description: 노트북의 설명입니다.

노트북 정의를 가져오기

전체 전자 필기장 콘텐츠를 .ipynb 형식으로 검색하는 데 notebookutils.notebook.getDefinition()를 사용합니다. 백업, 마이그레이션, 버전 제어 또는 콘텐츠 분석에 사용합니다.

매개 변수

Notebook 정의 검색 및 저장

# 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 = ""))

다른 작업 영역에서 Notebook 정의 가져오기

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}")

반환 값

이 메서드는 getDefinition() JSON 형식의 Notebook 콘텐츠를 포함하는 문자열을 .ipynb 반환합니다.

백업을 위해 모든 Notebook 내보내기

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()

전자 필기장 업데이트

notebookutils.notebook.update()을 사용하여 표시 이름 및 설명과 같은 Notebook 메타데이터를 변경합니다. Notebook 콘텐츠 또는 레이크하우스 구성은 변경하지 않습니다.

매개 변수

Notebook 이름 바꾸기

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

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

반환 값

메서드는 update() 업데이트된 속성이 있는 Artifact 개체를 반환합니다.

노트북 정의 업데이트

notebookutils.notebook.updateDefinition()를 사용하여 Notebook 콘텐츠, 기본 레이크하우스 또는 둘 다를 수정할 수 있습니다. 메타데이터 대신 Notebook 정의를 변경해야 하는 경우 사용합니다.

매개 변수

전자 필기장 콘텐츠 업데이트

# 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))

기본 레이크하우스 변경

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

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

콘텐츠와 레이크하우스를 모두 업데이트합니다.

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}")

반환 값

이 메서드는 updateDefinition() 업데이트가 성공하거나 True 실패하는 경우 반환 False 됩니다.

노트북 삭제하기

notebookutils.notebook.delete()을(를) 사용하여 작업 영역에서 노트북을 영구적으로 제거합니다. 삭제가 성공하면 반환 True 되며, 그렇지 않으면 반환됩니다 False.

매개 변수

반환 값

delete() 삭제가 성공하거나 True 실패하는 경우 메서드가 반환 False 됩니다.

노트북 삭제하기

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")
}

패턴별로 전자 필기장 안전하게 정리

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)

노트 목록

notebookutils.notebook.list()를 사용하여 작업 영역에서 노트북을 열거합니다. 개체 배열 Artifact 을 반환합니다.

매개 변수

현재 작업 영역의 모든 Notebook 나열

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, ")"))
}

다른 작업 영역의 Notebook 나열

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

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

반환 값

메서드는 list() 개체의 배열을 Artifact 반환합니다. 각 개체에는 displayName, id및 description 속성이 포함됩니다.

이름 패턴별로 Notebook 필터링

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}")

전자 필기장 복제

list() 및 getDefinition()를 함께 사용하여 동일한 작업 영역 내 또는 다른 작업 영역으로 Notebook을 복제합니다.

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")

Notebook을 다른 작업 영역으로 마이그레이션

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")

관련 콘텐츠

• Fabric용 NotebookUtils
• NotebookUtils Notebook 실행