Migrace z Fabric Runtime 1.3 na Runtime 2.0

Fabric Runtime 2.0 je nejnovější obecně dostupný (GA) a výchozí runtime pro pracovní zátěže Apache Spark v Microsoft Fabric. Aktualizuje operační systém, Java, Scala, Python, R, Apache Spark a Delta Lake. Protože některé z těchto aktualizací překračují hranice hlavních verzí, ověřte si své poznámkové bloky, definice úloh ve Sparku, knihovny a datové pipeline před přesunem produkčních pracovních zátěží z Runtime 1.3.

Tento průvodce popisuje změny, které mohou ovlivnit migraci, a poskytuje postupný proces pro přesun vašich pracovních zátěží do Runtime 2.0.

Co se změnilo v Runtime 2.0

Následující tabulka porovnává hlavní komponenty v Runtime 1.3 a Runtime 2.0.

Component	Runtime 1.3	Runtime 2.0	Úvahy o migraci
Fáze vydání	Oznámen konec podpory (EOSA)	GA	Migrujte produkční pracovní zátěže do podporovaného GA runtime.
Apache Spark	3.5.5	4.1.1	Zkontrolujte změny chování Spark 4.1 a odstraněná API.
Delta Lake	3.2	4.2	Ověřte funkce tabulek a kompatibilitu protokolů napříč všemi úlohami Fabric, které používají vaše tabulky.
Java	11	21	Přestavte a otestujte Java knihovny a závislosti Java Native Interface (JNI).
Scala	2.12.17	2.13.16	Překompilujte soubory Scala JAR pro Scala 2.13. Artefakty ze Scala 2.12 a 2.13 nejsou binárně kompatibilní.
Python	3.11	3.13	Ověřte, že každý balíček Pythonu poskytuje vydání kompatibilní s Pythonem 3.13 a Linux wheel.
R	4.4.1	4.5.2	Přeinstalujte a otestujte vlastní balíčky R. SparkR je ve Spark 4.1 označen jako zastaralý.
Operační systém	Azure Linux 2.0 (Mariner 2.0)	Azure Linux 3.0 (Mariner 3.0)	Znovu sestavte nativní knihovny a vlastní binárky pro Azure Linux 3.0.

Runtime 2.0 také přináší nové možnosti Apache Spark 4.1, včetně datového typu VARIANT, SQL uživatelsky definovaných funkcí, proměnných relace, rourkové syntaxe, třídění řetězců, Python Data Source API, uživatelsky definovaných tabulkových funkcí v Pythonu, jednotného profilování PySpark a nových API pro správu stavu a ladění Structured Streaming. Pro přehled viz Runtime 2.0 v Fabric.

Zkontrolujte změny kompatibility

Před změnou pracovního prostoru nebo prostředí na Runtime 2.0 si prostudujte následující oblasti.

Vestavěné a vlastní knihovny

Runtime 2.0 odstraňuje několik předinstalovaných balíčků pro Python a R, které byly dostupné v Runtime 1.3. Snížení výchozí sady balíčků udržuje běhové prostředí odlehčené a snižuje prostor pro potenciální bezpečnostní incidenty. Balík, který byl v Runtime 1.3 dostupný bez konfigurace, může být nutné explicitně přidat do vašeho prostředí Runtime 2.0.

Použijte Library Manager k přidání pouze balíčků, které vaše úloha vyžaduje, a pak uložte a publikujte prostředí. Správce knihovny vyřeší požadované závislosti balíčku, proto nepřidávejte každou závislost do následujících seznamů zvlášť. Nepředpokládejte, že knihovna je dostupná nebo že její verze zůstává beze změn:

Porovnejte inventáře balíčků Runtime 1.3 a Runtime 2.0 v repozitáři runtime releases Fabric.
Přidejte chybějící knihovny PyPI, Conda, Maven, R nebo vlastní knihovny do prostředí a publikujte ho.
Připněte verze pro produkční pracovní zátěže, aby bylo možné opakovat řešení závislostí.
Ověřte, že balíčky Python podporují Python 3.13. Balíčky s nativními rozšířeními musí poskytovat kompatibilní Linux wheel nebo být úspěšně sestaveny na Azure Linux 3.0.
Nahraďte závislosti pro Scala 2.12 artefakty pro Scala 2.13. Názvy artefaktů běžně zahrnují binární verzi Scala, například _2.12 nebo _2.13.
Překompilujte vlastní JAR soubory proti Java 21, Scala 2.13 a Spark 4.1. Testujte tranzitivní závislosti, zda nejsou v konfliktu s knihovnami poskytovanými za běhu.
Znovu sestavte vlastní nativní knihovny pro Azure Linux 3.0.

Fabric migruje specifikace knihoven při změně modulu runtime existujícího prostředí, ale nemůže zaručit, že tyto knihovny zůstanou kompatibilní. Publikování selže, když řešení závislostí najde konflikt. Pro možnosti instalace balíčků a režimy publikování viz Správa knihoven v Fabric prostředích.

Balíčky odstraněné z výchozího prostředí

Následující inventáře zahrnují balíčky určené pro uživatele a jejich nízkoúrovňové nebo tranzitivní závislosti. Hledejte v těchto seznamech balíčky, které používá vaše úloha Runtime 1.3. Pokud je balíček uveden, přidejte verzi kompatibilní s Python 3.13 nebo R 4.5 prostřednictvím Library Manager ve vašem prostředí Runtime 2.0.

Prostředí Python: 348 Conda balíčků

Package	Package	Package	Package
`_libgcc_mutex`	`_sysroot_linux-64_curr_repodata_hack`	`abseil-cpp`	`alabaster`
`aom`	`appdirs`	`archspec`	`argon2-cffi`
`argon2-cffi-bindings`	`arrow`	`arrow-cpp`	`asgiref`
`asn1crypto`	`astropy`	`async_generator`	`async-lru`
`async-timeout`	`autopep8`	`aws-c-auth`	`aws-c-cal`
`aws-c-common`	`aws-c-compression`	`aws-c-event-stream`	`aws-c-http`
`aws-c-io`	`aws-c-mqtt`	`aws-c-s3`	`aws-c-sdkutils`
`aws-checksums`	`aws-crt-cpp`	`aws-sdk-cpp`	`azure-keyvault`
`azure-storage`	`babel`	`backports`	`backports.shutil_get_terminal_size`
`bcrypt`	`beautifulsoup4`	`binaryornot`	`binutils_impl_linux-64`
`binutils_linux-64`	`bitarray`	`bkcharts`	`black`
`blas`	`bleach`	`blinker`	`blosc`
`bokeh`	`boltons`	`boost-cpp`	`boto`
`bottleneck`	`brunsli`	`c-ares`	`c-blosc2`
`cached-property`	`cfitsio`	`chardet`	`charls`
`cmake`	`cmdstan`	`conda-package-handling`	`conda-package-streaming`
`configparser`	`contextlib2`	`cookiecutter`	`curl`
`cython`	`cytoolz`	`daal4py`	`dal`
`dask`	`dask-core`	`dataclasses`	`datasets`
`dav1d`	`dill`	`distributed`	`distro`
`django`	`docutils`	`entrypoints`	`expat`
`fastcache`	`flake8`	`flit`	`flit-core`
`fmt`	`fonts-anaconda`	`future`	`gcc_impl_linux-64`
`gcc_linux-64`	`geographiclib`	`geopy`	`get_terminal_size`
`gevent`	`gflags`	`giflib`	`glib`
`glob2`	`glog`	`gmp`	`gmpy2`
`gobject-introspection`	`grpc-cpp`	`gst-plugins-base`	`gstreamer`
`gtk2`	`gxx_impl_linux-64`	`gxx_linux-64`	`hdf5`
`heapdict`	`html5lib`	`huggingface_hub`	`imagecodecs`
`imageio`	`imagesize`	`inflection`	`iniconfig`
`intel-openmp`	`intervaltree`	`ipython_genutils`	`jaraco.classes`
`jeepney`	`jpeg`	`json5`	`jsonpatch`
`jsonpointer`	`jupyter_console`	`jupyter_events`	`jupyter-lsp`
`jupyter_server`	`jupyter_server_terminals`	`jupyterlab`	`jupyterlab_pygments`
`jupyterlab_server`	`jxrlib`	`kernel-headers_linux-64`	`keyring`
`lazy_loader`	`lazy-object-proxy`	`liac-arff`	`libaec`
`libarchive`	`libavif`	`libclang`	`libcurl`
`libev`	`libevent`	`libgcc-devel_linux-64`	`libgfortran-ng`
`liblief`	`libllvm14`	`libmamba`	`libmambapy`
`libnghttp2`	`libprotobuf`	`libsolv`	`libspatialindex`
`libssh2`	`libstdcxx-devel_linux-64`	`libthrift`	`libtool`
`libwebp`	`libzopfli`	`lightning-utilities`	`llvm-openmp`
`llvmlite`	`locket`	`lxml`	`lz4`
`lz4-c`	`lzo`	`make`	`markdown`
`mccabe`	`menuinst`	`minio`	`mistune`
`mkl`	`mkl_fft`	`mkl_random`	`mkl-service`
`mock`	`more-itertools`	`mpc`	`mpfr`
`mpi`	`mpich`	`mpmath`	`msgpack-python`
`msrest`	`multipledispatch`	`multiprocess`	`mysql`
`nbclassic`	`nbclient`	`nbconvert`	`nest-asyncio`
`networkx`	`ninja`	`ninja-base`	`nose`
`notebook`	`notebook-shim`	`nspr`	`nss`
`numba`	`numexpr`	`numpy-base`	`numpydoc`
`oauthlib`	`olefile`	`openml`	`orc`
`overrides`	`pandocfilters`	`paramiko`	`partd`
`patch`	`patchelf`	`path`	`path.py`
`pathlib2`	`pep8`	`pickleshare`	`pkginfo`
`pluggy`	`ply`	`poppler`	`poppler-data`
`prettytable`	`prometheus_client`	`py-cpuinfo`	`py-lief`
`pybind11-abi`	`pycodestyle`	`pycosat`	`pycurl`
`pydocstyle`	`pyerfa`	`pyflakes`	`pynacl`
`pyopenssl`	`pyqt`	`pyqt5-sip`	`pyrsistent`
`pytables`	`pytest`	`python-fastjsonschema`	`python-json-logger`
`python-libarchive-c`	`python-lmdb`	`python-slugify`	`python-xxhash`
`pytorch`	`pytorch-lightning`	`pytorch-mutex`	`pywavelets`
`qdarkstyle`	`qstylizer`	`qt`	`qt-main`
`qt-webengine`	`qtawesome`	`qtconsole`	`qtpy`
`re2`	`reproc`	`reproc-cpp`	`requests-oauthlib`
`rfc3339-validator`	`rfc3986-validator`	`rhash`	`ripgrep`
`rtree`	`s2n`	`safetensors`	`scikit-build`
`scikit-image`	`scikit-learn-intelex`	`secretstorage`	`send2trash`
`shap`	`simplegeneric`	`singledispatch`	`sip`
`slicer`	`snappy`	`snowballstemmer`	`sortedcollections`
`sortedcontainers`	`soupsieve`	`sphinx`	`sphinxcontrib`
`sphinxcontrib-applehelp`	`sphinxcontrib-devhelp`	`sphinxcontrib-htmlhelp`	`sphinxcontrib-jsmath`
`sphinxcontrib-qthelp`	`sphinxcontrib-serializinghtml`	`sphinxcontrib-websupport`	`sqlite`
`sympy`	`sysroot_linux-64`	`tbb`	`tbb-devel`
`tbb4py`	`tblib`	`terminado`	`testpath`
`text-unidecode`	`textdistance`	`tifffile`	`tinycss2`
`tokenizers`	`toml`	`tomli-w`	`toolz`
`torchdata`	`torchmetrics`	`transformers`	`truststore`
`typed-ast`	`ujson`	`unicodecsv`	`unidecode`
`utf8proc`	`webencodings`	`websocket-client`	`wheel`
`whichcraft`	`xlsxwriter`	`xlwt`	`xmltodict`
`xxhash`	`xyzservices`	`xz`	`yaml-cpp`
`yapf`	`zfp`	`zict`	`zlib`
`zope`	`zope.event`	`zope.interface`	`zstandard`

Python prostředí: 24 pip balíčků

Package	Package	Package	Package
`accelerate`	`astor`	`dash`	`dash-core-components`
`dash-cytoscape`	`dash-html-components`	`dash-table`	`docker`
`interpret`	`interpret-core`	`json-tricks`	`nni`
`nvidia-ml-py`	`pyperclip`	`pythonwebhdfs`	`responses`
`retrying`	`salib`	`schema`	`seqeval`
`simplejson`	`tensorboardx`	`thop`	`typeguard`

R prostředí: 67 Conda balíčků

Package	Package	Package	Package
`_libgcc_mutex`	`_sysroot_linux-64_curr_repodata_hack`	`blosc`	`cfitsio`
`expat`	`fmt`	`freetype`	`freexl`
`geos`	`geotiff`	`giflib`	`hdf4`
`hdf5`	`json-c`	`kealib`	`lcms2`
`libaec`	`libarchive`	`libgdal`	`libgdal-core`
`libgdal-fits`	`libgdal-grib`	`libgdal-hdf4`	`libgdal-hdf5`
`libgdal-jp2openjpeg`	`libgdal-kea`	`libgdal-netcdf`	`libgdal-pdf`
`libgdal-pg`	`libgdal-postgisraster`	`libgdal-tiledb`	`libgdal-xls`
`libkml`	`libnetcdf`	`libnsl`	`librttopo`
`libspatialite`	`libsqlite`	`libudunits2`	`libv8`
`libzip`	`lzo`	`minizip`	`nspr`
`nss`	`openjpeg`	`poppler`	`poppler-data`
`proj`	`r-classint`	`r-gsl`	`r-jose`
`r-mgcv`	`r-s2`	`r-sf`	`r-units`
`r-wk`	`spdlog`	`sqlite`	`tiledb`
`uriparser`	`xerces-c`	`xorg-kbproto`	`xorg-renderproto`
`xorg-xextproto`	`xorg-xproto`	`xz`

Note

Pokud ochrana odchozího přístupu nebo spravovaná virtuální síť brání přístupu k veřejným repozitářům, stáhněte si kompatibilní wheel soubory nebo hostujte zrcadlo balíčků. Instrukce najdete v článku Spravovat knihovny s omezeným přístupem k síti ve Fabric.

Změny konfigurace Sparku

Runtime 2.0 přidává a odstraňuje nastavení Spark a mění některé výchozí hodnoty. Fabric také používá jiné výchozí nastavení oproti Apache Spark pro některá nastavení.

Před migrací si prostudujte nastavení Sparku, která jste nastavili pro své pracovní prostory, prostředí, notebooky a definice úloh Spark. Odstraňte nastavení, která už nejsou podporována, a testujte pracovní zátěže, které závisí na změněných výchozích nastaveních. Používejte výchozí nastavení za běhu, pokud dokumentace neuvádí, že máte nastavení změnit.

Významné změny výchozích hodnot

Následující tabulka uvádí vybrané změny výchozího stavu. Nenastaveno znamená, že základní hodnota explicitně nenastavuje hodnotu; neznamená to, že je funkce deaktivovaná.

Configuration	Hodnota Runtime 1.3	Hodnota modulu Runtime 2.0	Úvahy o migraci
`spark.checkpoint.compress`	`false`	`true`	Soubory kontrolních bodů jsou ve výchozím nastavení komprimované. Ověřte interoperabilitu kontrolních bodů a chování úložiště.
`spark.databricks.delta.optimizeWrite.enabled`	`true`	Nenastaví se	Vlastnost není odstraněna. Ověřte platné chování optimalizovaného zápisu pomocí nastavení tabulky, relace a profilu zdrojů.
`spark.databricks.delta.optimizeWrite.partitioned.enabled`	`false`	`true`	Ověřte propustnost zápisu a velikost výstupních souborů pro rozdělené tabulky Delta.
`spark.hadoop.parquet.block.size`	`1073741824` (1 GiB)	`134217728` (128 MiB)	Zapisovače Parquetu se zaměřují na menší bloky. Ověřte velikost souborů a výkon následného čtení.
`spark.microsoft.delta.optimize.fast.enabled`	`false`	`true`	`OPTIMIZE` může práci vynechat, ledaže jsou splněna kritéria počtu souborů nebo odhadované velikosti zhutnění. Ověřte výsledky údržby.
`spark.microsoft.delta.optimize.fileLevelTarget.enabled`	`false`	`true`	Soubory, které dříve splnily alespoň polovinu své cílové velikosti pro zhutnění, se už znovu nezkompaktují. Po `OPTIMIZE` ověřte rozložení souboru.
`spark.microsoft.delta.targetFileSize.adaptive.enabled`	`false`	`true`	Delta vypočítává cílovou velikost souboru na základě velikosti tabulky. Ověřte výsledné velikosti souborů a rychlost čtení.
`spark.speculation.multiplier`	`1.5`	`3`	Úkol musí běžet třikrát pomaleji než medián, než ho Spark zváže pro spekulativní provedení.
`spark.speculation.quantile`	`0.75`	`0.9`	Spark čeká na dokončení 90 % úkolů, než považuje spekulativní provádění za vhodné.
`spark.sql.files.maxPartitionBytes`	`134217728` (128 MiB)	`536870912` (512 MiB)	Skeny souborů mohou do každého oddílu zabalit více dat. Ověřte paralelismus a využití paměti executora.
`spark.sql.maxSinglePartitionBytes`	`Long.MaxValue`	`128m`	Jeden oddíl je ve výchozím nastavení omezen na 128 MiB. Ověřujte dotazy, které vedou k vytvoření jednoho velkého oddílu.
`spark.sql.orc.compression.codec`	`snappy`	`zstd`	Nové zápisy ORC používají kompresi Zstandard ve výchozím nastavení. Ověřte kompatibilitu a výkon s navazujícími čtečkami.
`spark.sql.sources.v2.bucketing.enabled`	`false`	`true`	Spark ve výchozím nastavení umožňuje spojení dělená podle oddílů úložiště a další chování seskupování (bucketing) v Data Source V2. Ověřte plány dotazů a výsledky.
`spark.sql.sources.v2.bucketing.pushPartValues.enabled`	`false`	`true`	Spark může prosazovat kompatibilní hodnoty oddílů pro Data Source V2 bucketing. Ověřte plány dotazů pro bucketované tabulky.

Runtime 2.0 také používá ROCKSDB místo LEVELDB pro spark.shuffle.service.db.backend a nastavuje spark.shuffle.service.removeShuffle na true. Spark používá externí službu shuffle k mazání zbytečných shuffle bloků pro uvolněné executory.

Delta paralelní načítání snapshotů, paralelní přeskakování dat a načítání snapshotů na straně ovladače se také mění z false na true. Testujte latenci dotazů a využití prostředků ovladače, zejména u dotazů, které přistupují k více tabulkám Delta.

Přepsání při spuštění relace a nativní provádění

Nasazení funkcí Fabric může přepsat výchozí hodnoty při zahájení relace.

Configuration	Základní hodnota Runtime 2.0	Hodnota spuštění relace v Runtime 2.0 ve veřejných produkčních regionech	Úvahy o migraci
`spark.gluten.sql.columnar.costBasedFallback.enabled`	`false`	`true`	Produkční nasazení zaznamenané 16. října 2026 umožňuje návrat ke Sparku založený na nákladech. Znovu zkontrolujte plány dotazů a výkon, včetně pracovních zátěží testovaných před tímto nasazením.
`spark.sql.parquet.native.writer.complexTypes.enabled`	`false`	`true`	Testujte nativní zápisy a navazující čtení v rámci Parquetu pro pole, mapy a struktury.

Když používáte nativní spouštěcí engine, zahrňte do regresních testů následující kontroly:

Ověřte využití paměti při zvýšení výchozí velikosti sloupcové dávky z 4 096 na 10 240.
Porovnejte plány shuffle a výkon s prahem pro řazení založené na sloupcovém shuffle, který klesá ze 100 000 na 4 000 oddílů.
Porovnejte výsledky regulárních výrazů a výkon. Podpora regulárních výrazů Java v nativním enginu se mění z vypnuté na povolenou a nastavení, které vrací všechny výrazy regex zpět do Sparku, se mění z true na false.

Výchozí nastavení Apache Spark 4.1 je v Fabric zachováno odlišně

Fabric Runtime 2.0 záměrně nahrazuje následující výchozí nastavení Apache Spark 4.1. Nepředpokládejte, že výchozí nastavení Spark 4.1 v Fabric platí beze změny.

Configuration	Výchozí nastavení Apache Spark 4.1	Hodnota Fabric Runtime 2.0
`spark.eventLog.compress`	`true`	`false`
`spark.eventLog.rolling.enabled`	`true`	`false`
`spark.sql.ansi.enabled`	`true`	`false`
`spark.sql.catalog.spark_catalog`	`builtin`	`org.apache.spark.sql.delta.catalog.DeltaCatalog`
`spark.sql.hive.metastore.version`	`2.3.10`	`2.3.2`

Chování Spark SQL a DataFrame

Spark 4.1 zavádí změny chování, které mohou změnit výsledky dotazů nebo způsobit, že dříve přijaté dotazy selžou. Věnujte zvláštní pozornost chování ANSI SQL, castům, operacím s datem a časovými značkami, datovým typům, mapování JDBC a zastaralým SQL konfiguracím.

Spusť regresní testy, které porovnávají:

Výstupní schémata, včetně typu, přesnosti, škálování a nulovatelnosti.
Počet řádků a souhrnné výsledky.
Null, overflow, dělení nulou a neplatné přetypování.
Datum, časové razítko, časové pásmo a výsledky pro intervaly.
Mapování typů zdrojů a sinků JDBC.
Plány dotazů a výkon kritických pracovních zátěží.

Nepoužívejte nastavení kompatibility starších verzí jako trvalou migrační strategii. Pokud dočasně použijete některé z nich k izolaci selhání, aktualizujte postižený kód a odstraňte toto nastavení před dokončením migrace. Pro kompletní sadu změn chování viz migrační příručku pro Spark SQL.

Python a pandas API na Sparku

Runtime 2.0 přechází z Python 3.11 na Python 3.13 a obsahuje změny PySpark zavedené ve Spark 4.1. Spark 4.1 také zvyšuje minimální podporované verze pandas, NumPy a PyArrow a odstraňuje API, která byla v dřívějších verzích zastaralá.

Mezi běžné aktualizace pandas API na Sparku patří:

Nahraďte DataFrame.iteritems a Series.iteritems za items.
Nahraďte DataFrame.append a Series.append pomocí ps.concat.
Nahraďte u kategorických operací odstraněné inplace parametry přiřazeními.
Zkontrolujte změněné názvy parametrů a výchozí hodnoty, například inclusive a Series.str.replace(regex=...).
Ověřte názvy sloupců výsledků, názvy indexů, dtypy a pořadí.

Kompletní seznam najdete v Průvodci migrací PySparku.

Aplikace v Java a Scala

Scala 2.13 není binárně kompatibilní se Scalou 2.12. Opětovné použití JAR Runtime 1.3 v Runtime 2.0 může způsobit chyby při načítání tříd i tehdy, když se zdrojový kód nezměnil. Vytvořte samostatný artefakt Runtime 2.0 a aktualizujte všechny závislosti sestavené pro více verzí Scaly.

Spark 4.1 také mění své odkazy na interní servlet API z javax na jakarta. Zkontrolujte vlastní listenery, rozšíření Sparku a knihovny, které interagují s interními součástmi Sparku. Pro další změny na úrovni enginu viz průvodce migrací Spark Core.

Streamovací pracovní zátěže a konektory

Zastaralá součást EventHubConnector zahrnutá v Runtime 1.3 není dostupná v Runtime 2.0. Použijte konektor Apache Spark Kafka s Kafka-kompatibilním endpointem pro Azure Event Hubs. Pro pokyny k nastavení viz Use Apache Spark with Azure Event Hubs for Apache Kafka.

Pro relevantní scénáře můžete také vyzkoušet Fabric Eventstream pro ingest streamovacích dat a jejich zpracování v notebooku pomocí Spark Structured Streaming. Pro více informací viz Dotazování na eventstream v Microsoft Fabric z poznámkového bloku pomocí Spark Structured Streaming.

Pro každou zátěž strukturovaného streamování:

Otestujte, zda lze dotaz Runtime 2.0 restartovat z kopie existujícího kontrolního bodu.
Ověřujte stavové operace, vodoznaky v čase událostí, spouštěče, možnosti zdroje a cíle a výstupní schémata.
Nechte zdrojová data a původní kontrolní bod k dispozici až do dokončení ověření.
Pokud je kontrolní bod neslučitelný, naplánujte kontrolovaný restart s novým kontrolním bodem. Zohledněte opakované nebo přeskočené vstupy a před restartem zajistěte, aby byl cíl idempotentní.

Prohlédněte si migrační průvodce Structured Streaming ohledně změn kompatibility s upstreamem.

Tabulky Delta Lake

Delta Lake udržuje zpětnou kompatibilitu pro existující tabulky, takže Runtime 2.0 může pracovat s tabulkami vytvořenými v Runtime 1.3. Povolení novější funkce tabulky však může zvýšit čtecí nebo zapisovací protokol tabulky a zabránit starším enginům nebo jiným prostředím Fabric v používání tabulky.

Během počáteční migrace za běhu:

Neupgradujte protokoly tabulek ani nezapínejěte funkce Delta Lake 4.2.
Prohlédněte si vlastnosti a verze protokolu nově vytvořených tabulek i stávajících tabulek. Runtime 2.0 nastavuje spark.databricks.delta.properties.defaults.enableDeletionVectors na true; ověřte výsledná metadata tabulky namísto toho, abyste předpokládali, že vyhnutí se manuálnímu zpřístupnění funkcí zachovává kompatibilitu.
Testuje čtení, zápis, slučování, vývoj schématu, údržbové operace a souběžný přístup.
Identifikujte každý engine, který čte nebo zapisuje každou tabulku, včetně SQL analytického endpointu, Power BI, pipeline, datových toků, eventstreamů a externích enginů.
Novou funkci Delta povolte až poté, co ji všichni příjemci budou podporovat.

Specifické funkce Delta Lake 4.2 jsou ve Fabric experimentální a omezeny pouze na prostředí Spark. Pro podpůrnou matici a výchozí verze protokolu viz interoperabilita formátu tabulek Delta Lake.

Migrujte své pracovní zátěže

Použijte postupnou migraci namísto okamžité změny runtime v produkčním pracovním prostoru.

1. Inventarizujte své úlohy Runtime 1.3

Poznamenejte si následující informace:

Poznámkové bloky, definice úloh Spark, kanály, rozvrhy a závislé položky.
Přiřazení prostředí na úrovni pracovního prostoru a na úrovni položky.
Konfigurace Sparku, včetně jakýchkoli starších nastavení kompatibility.
Veřejné, soukromé a vlastní knihovny a jejich výsledné verze.
Vlastní soubory JAR, Python wheely, balíčky R, nativní knihovny a logika inicializace.
Zdroje dat, cíle, tajné klíče, spojení a požadavky na síť.
Delta tabulky a všechny jiné než Spark konzumenty těchto tabulek.
Streamovací kontrolní body, schémata, offsety a požadavky na obnovu.
Očekávaná schémata výstupu, počet řádků, kontroly kvality dat a referenční hodnoty výkonu.

Upřednostněte pracovní zátěže, které využívají vlastní knihovny, nativní kód, Scalu, streamovací stav nebo pokročilé funkce Delty.

2. Vytvořit testovací prostředí Runtime 2.0

Vytvořte samostatnou položku prostředí a vyberte 2.0 (Spark 4.1, Delta 4.2) jako jeho runtime. Přidejte potřebné knihovny, uložte prostředí a publikujte ho. Připojte prostředí ke kopiím reprezentativních zápisníků a definic úloh ve Sparku v vývojovém nebo testovacím pracovním prostoru.

Pokud váš produkční pracovní prostor stále používá Runtime 1.3, neměňte jeho runtime, dokud testování nebude dokončeno. Ponechte stávající konfiguraci dostupnou pro případ vrácení zpět během ověřování.

Pro ověření nadcházejících aktualizací Runtime 2.0 dříve, než dorazí do výchozího kanálu, použijte kanál early access ve svém testovacím prostředí. Pro více informací viz kanály vydávání modulu runtime Fabric.

3. Aktualizujte knihovny a kód

Aplikujte změny uvedené v přezkumu kompatibility:

Nahraďte chybějící předinstalované balíčky explicitními závislostmi prostředí.
Upgradujte nebo nahraďte balíčky, které nepodporují Python 3.13, Java 21, Scala 2.13 nebo Azure Linux 3.0.
Znovu sestavte vlastní soubory JAR a nativní binární soubory.
Aktualizace odstranila volání PySpark a pandas API ve voláních Spark.
Vyměňte EventHubConnector za konektor Kafka.
Odstraňte nastavení Spark pro konfigurace, které nejsou dostupné v Runtime 2.0, a zkontrolujte explicitní přepsání konfigurací, jejichž výchozí nastavení se změnilo.
Vyřešit rozdíly chování SQL ve Spark v kódu místo trvalého spoléhání se na starší nastavení.
Během této fáze ponechat stávající funkce a protokoly tabulky Delta beze změny.

4. Spouštějte testy kompatibility a regresí

Spusť stejné reprezentativní vstupy na Runtime 1.3 a Runtime 2.0. Porovnat:

Stav dokončení, záznamy, varování a opakované pokusy.
Schémata a datové typy.
Výsledky na úrovni řádků a souhrnné výsledky.
Historie a protokol tabulky Delta.
Průběh streamování, stav, latence a zpracování duplicit.
Doba provedení, spotřeba zdrojů a náklady.
V navazujících systémech se projeví v analytickém koncovém bodu SQL, Power BI, pipelinech a dalších konzumentech.

Zahrňte testy selhání a zotavení, nejen úspěšná spuštění. Restarty testovacích relací, opakování úloh, obnova kontrolních bodů a souběžný přístup k tabulce.

5. Nasaďte Runtime 2.0

Přesouvej pracovní zátěže v kontrolovaných dávkách:

Publikujte ověřené prostředí Runtime 2.0.
Připojte to k malé sadě produkčních notebooků nebo definic úloh Spark.
Spusťte dávku a monitorujte výstupy a následné odběratele.
Pokračujte ve zbývajících úlohách po uplynutí pozorovacího období.
Nastavte Runtime 2.0 jako výchozí pro pracovní prostor až po dokončení migrace na úrovni položek.

Změna runtime pracovního prostoru ovlivňuje nové Spark relace. Stávající relace pokračují v používání svého aktuálního runtime, dokud nepřestanou.

6. Udržujte možnost návratu

Udržujte prostředí Runtime 1.3, artefakty, specifikace knihovny a kontrolní body streamování až do konce pozorovacího období Runtime 2.0. Pro návrat zpět připojte znovu prostředí Runtime 1.3 nebo obnovte předchozí runtime pracovního prostoru a začněte novou Spark relaci.

Důležité

Upgrade protokolu Delta obecně není vratný. Nepovolujte funkce tabulek, které zvyšují protokol, dokud nedokončíte validaci v Runtime 2.0 a nepotvrdíte kompatibilitu se všemi konzumenty tabulek.

Kontrolní seznam pro migraci

Před dokončením migrace si ověřte, že:

[ ] Každý požadovaný balíček pro Python a R je explicitně dostupný a kompatibilní s Python 3.13 nebo R 4.5.
[ ] Vlastní JAR soubory cílí na Java 21, Scala 2.13 a Spark 4.1.
[ ] Nativní závislosti fungují na Azure Linux 3.0.
[ ] Nastavení pracovního prostoru, prostředí, poznámkového bloku a definice úloh Spark nepoužívají odstraněné konfigurace Sparku.
[ ] Pracovní zátěže jsou testovány proti změněným výchozím nastavením konfigurace Spark v Runtime 2.0.
[ ] Regresní testy Spark SQL a PySpark prošly.
[ ] Pracovní zátěže Event Hubů používají konektor Kafka.
[ ] Zátěže strukturovaného streamování se restartují a obnovují tak, jak je navrženo.
[ ] Protokoly a funkce tabulky Delta zůstávají kompatibilní se všemi konzumenty.
[ ] Kvalita dat, výkon a náklady splňují vaše kritéria přijetí.
[ ] Postupy zavádění, monitorování a rollbacku jsou dokumentovány a testovány.

Váš názor

Byla tato stránka užitečná?

Poslední aktualizace v 2026-10-23