Migreren van Fabric Runtime 1.3 naar Fabric Runtime 2.0

Fabric Runtime 2.0 is de nieuwste algemeen beschikbare (GA) en standaard runtime voor Apache Spark-workloads in Microsoft Fabric. Het werkt het besturingssysteem, Java, Scala, Python, R, Apache Spark en Delta Lake bij. Omdat verschillende van deze updates meerdere hoofdversies omvatten, valideer je je notebooks, Spark-jobdefinities, bibliotheken en datapijplijnen voordat je productieworkloads vanaf Runtime 1.3 migreert.

Deze gids beschrijft de wijzigingen die een migratie kunnen beïnvloeden en biedt een gefaseerd proces om je workloads naar Runtime 2.0 te verplaatsen.

Wat is er veranderd in Runtime 2.0

De volgende tabel vergelijkt de primaire componenten in Runtime 1.3 en Runtime 2.0.

Component	Speeltijd 1.3	Runtime 2.0	Migratieoverwegingen
Releasefase	Einde van de ondersteuning aangekondigd (EOSA)	GA	Migreer productieworkloads naar de ondersteunde GA-runtime.
Apache Spark	3.5.5	4.1.1	Bekijk gedragswijzigingen in Spark 4.1 en verwijderde API's.
Delta Lake	3.2	4.2	Valideer de tabelfuncties en protocolcompatibiliteit in elke Fabric-werklast waarin je tabellen worden gebruikt.
Java	11	21	Herbouw en test Java-bibliotheken en Java Native Interface (JNI)-afhankelijkheden.
Scala	2.12.17	2.13.16	Recompileer Scala JAR-bestanden voor Scala 2.13. Artefacten van Scala 2.12 en 2.13 zijn niet binair compatibel.
Python	3.11	3.13	Controleer of elk Python-pakket een Python 3.13-compatibele release en een Linux wheel biedt.
R	4.4.1	4.5.2	Installeer aangepaste R-pakketten opnieuw en test deze. SparkR is verouderd in Spark 4.1.
besturingssysteem	Azure Linux 2.0 (Mariner 2.0)	Azure Linux 3.0 (Mariner 3.0)	Herbouw native bibliotheken en aangepaste binaries voor Azure Linux 3.0.

Runtime 2.0 biedt ook nieuwe Apache Spark 4.1-mogelijkheden, waaronder het gegevenstype VARIANT, door gebruikers gedefinieerde SQL-functies, sessievariabelen, pipesyntaxis, string-collatie, de Python Data Source API, Python-gebruikersgedefinieerde tabelfuncties, uniforme PySpark-profilering en nieuwe Structured Streaming state-management- en debugging-API's. Voor een overzicht, zie Runtime 2.0 in Fabric.

Compatibiliteitswijzigingen controleren

Bekijk de volgende gebieden voordat je een werkruimte of omgeving verandert naar Runtime 2.0.

Ingebouwde en aangepaste bibliotheken

Runtime 2.0 verwijdert verschillende vooraf geïnstalleerde Python- en R-pakketten die beschikbaar waren in Runtime 1.3. Het verlagen van de standaard pakketset houdt de runtime slank en verkleint het aanvalsoppervlak voor potentiële beveiligingsincidenten. Een pakket dat zonder configuratie beschikbaar was in Runtime 1.3, moet mogelijk expliciet worden toegevoegd aan je Runtime 2.0-omgeving.

Gebruik Library Manager om alleen de pakketten toe te voegen die je workload vereist, en sla vervolgens de omgeving op en publiceer deze. Library Manager bepaalt de vereiste afhankelijkheden van het pakket, dus voeg niet elke afhankelijkheid afzonderlijk toe in de volgende inventarissen. Ga er niet van uit dat een bibliotheek beschikbaar is of dat de versie ongewijzigd is:

Vergelijk de Runtime 1.3- en Runtime 2.0-pakketinventarissen in de Fabric runtime releases-repository.
Voeg ontbrekende PyPI-, Conda-, Maven-, R- of aangepaste bibliotheken toe aan een omgeving en publiceer die.
Zet versies vast voor productieworkloads om afhankelijkheidsresolutie herhaalbaar te maken.
Bevestig dat Python-pakketten Python 3.13 ondersteunen. Pakketten met native extensies moeten een compatibele Linux wheel bieden of succesvol gebouwd worden op Azure Linux 3.0.
Vervang Scala 2.12-afhankelijkheden door Scala 2.13-artefacten. Artefactnamen omvatten vaak de Scala binaire versie, zoals _2.12 of _2.13.
Compileer aangepaste JAR-bestanden opnieuw met Java 21, Scala 2.13 en Spark 4.1. Test transitieve afhankelijkheden op conflicten met door de runtime geleverde bibliotheken.
Herbouw aangepaste native bibliotheken voor Azure Linux 3.0.

Fabric migreert bibliotheekspecificaties wanneer je de runtime van een bestaande omgeving verandert, maar het kan niet garanderen dat die bibliotheken compatibel blijven. Publiceren mislukt wanneer het oplossen van afhankelijkheden een conflict oplevert. Voor pakketinstallatieopties en publicatiemodi, zie Bibliotheken beheren in Fabric-omgevingen.

Pakketten die uit de standaardomgeving zijn verwijderd

De volgende inventarissen omvatten gebruikersgerichte pakketten en hun laag-niveau of transitieve afhankelijkheden. Zoek in deze lijsten naar pakketten die door je Runtime 1.3-workload worden gebruikt. Als er een pakket wordt vermeld, voeg dan een Python 3.13- of R 4.5-compatibele versie toe via Library Manager in je Runtime 2.0-omgeving.

Python-omgeving: 348 Conda-pakketten

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-omgeving: 24-pip pakketten

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-omgeving: 67 Conda-pakketten

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

Als outbound access protection of een beheerd virtueel netwerk toegang tot publieke repositories verhindert, download dan compatibele wheel-bestanden of host een package mirror. Voor instructies, zie Bibliotheken beheren met beperkte netwerktoegang in Fabric.

Wijzigingen in de Spark-configuratie

Runtime 2.0 voegt Spark-instellingen toe en verwijdert Spark-instellingen en verandert enkele standaardwaarden. Fabric gebruikt ook andere standaardinstellingen dan Apache Spark voor sommige instellingen.

Bekijk voordat je migreert de Spark-instellingen die je hebt geconfigureerd voor je werkruimtes, omgevingen, notebooks en Spark-jobdefinities. Verwijder instellingen die niet meer worden ondersteund, en test workloads die afhankelijk zijn van gewijzigde standaardinstellingen. Gebruik de runtime-standaardinstellingen, tenzij de documentatie je aanraadt een instelling te wijzigen.

Opvallende wijzigingen in de standaardwaarde

De volgende tabel geeft een overzicht van geselecteerde basislijnwijzigingen. Niet ingesteld betekent dat de baseline geen expliciet waarde vaststelt; het betekent niet dat de functie is uitgeschakeld.

Configuration	Runtime 1.3-waarde	Runtime 2.0-waarde	Migratieoverwegingen
`spark.checkpoint.compress`	`false`	`true`	Checkpointbestanden worden standaard gecomprimeerd. Valideer interoperabiliteit en opslaggedrag van checkpoints.
`spark.databricks.delta.optimizeWrite.enabled`	`true`	Niet ingesteld	De eigenschap wordt niet verwijderd. Valideer het effectieve gedrag van optimized write met je tabel-, sessie- en resourceprofielinstellingen.
`spark.databricks.delta.optimizeWrite.partitioned.enabled`	`false`	`true`	Valideer schrijfdoorvoer- en uitvoerbestandsgroottes voor gepartitioneerde Delta-tabellen.
`spark.hadoop.parquet.block.size`	`1073741824` (1 GiB)	`134217728` (128 MiB)	Parquet-writers richten zich op kleinere blokken. Valideer bestandsgroottes en downstream-leesprestaties.
`spark.microsoft.delta.optimize.fast.enabled`	`false`	`true`	`OPTIMIZE` kan werk overslaan tenzij aan de criteria voor bestandsaantal of geschatte compactiegrootte is voldaan. Valideer onderhoudsresultaten.
`spark.microsoft.delta.optimize.fileLevelTarget.enabled`	`false`	`true`	Bestanden die eerder minstens de helft van hun compactiedoelgrootte bereikten, worden niet opnieuw gecompacteerd. Valideer bestandsindeling na `OPTIMIZE`.
`spark.microsoft.delta.targetFileSize.adaptive.enabled`	`false`	`true`	Delta berekent de doelbestandsgrootte op basis van de tabelgrootte. Valideer de resulterende bestandsgroottes en leesprestaties.
`spark.speculation.multiplier`	`1.5`	`3`	Een taak moet drie keer langzamer verlopen dan de mediaan voordat Spark deze overweegt voor speculatieve executie.
`spark.speculation.quantile`	`0.75`	`0.9`	Spark wacht tot 90% van de taken is afgerond voordat het speculatieve executie overweegt.
`spark.sql.files.maxPartitionBytes`	`134217728` (128 MiB)	`536870912` (512 MiB)	Bestandsscans kunnen meer gegevens per partitie opslaan. Controleer de paralleliteit en het gebruik van executor-geheugen.
`spark.sql.maxSinglePartitionBytes`	`Long.MaxValue`	`128m`	Een enkele partitie is standaard beperkt tot 128 MiB. Valideer queries die grote enkele partities produceren.
`spark.sql.orc.compression.codec`	`snappy`	`zstd`	Nieuwe ORC-schrijfacties gebruiken standaard Zstandard-compressie. Valideer compatibiliteit en prestaties met achterliggende lezers.
`spark.sql.sources.v2.bucketing.enabled`	`false`	`true`	Spark maakt standaard opslag-gepartitioneerde joins en ander Data Source V2 bucketing-gedrag mogelijk. Valideer queryplannen en resultaten.
`spark.sql.sources.v2.bucketing.pushPartValues.enabled`	`false`	`true`	Spark kan compatibele partitiewaarden pushen voor Data Source V2 bucketing. Valideer queryplannen voor gebucketiseerde tabellen.

Runtime 2.0 gebruikt ROCKSDB ook in plaats van LEVELDB voor spark.shuffle.service.db.backend en zet spark.shuffle.service.removeShuffle op true. Spark gebruikt de externe shuffle-service om onnodige shuffle-blokken voor gedealloceerde executors te verwijderen.

Het parallel laden van Delta-snapshots, het parallel overslaan van gegevens en het laden van snapshots aan de driverzijde veranderen ook van false naar true. Test query-latentie en het gebruik van driverbronnen, vooral voor query's die meerdere Delta-tabellen raadplegen.

Overrides voor sessiestart en native uitvoering

Fabric-functie-uitrols kunnen baselinewaarden overschrijven wanneer een sessie begint.

Configuration	Runtime 2.0 baselinewaarde	Runtime 2.0 sessie-startwaarde in publieke productieregio's	Migratieoverwegingen
`spark.gluten.sql.columnar.costBasedFallback.enabled`	`false`	`true`	De productie-uitrol die op 16 oktober 2026 plaatsvond, maakt kostengebaseerde fallback naar Spark mogelijk. Controleer de queryplannen en prestaties opnieuw, inclusief workloads die vóór die uitrol zijn getest.
`spark.sql.parquet.native.writer.complexTypes.enabled`	`false`	`true`	Test native Parquet-schrijfbewerkingen en downstream leesbewerkingen voor arrays, maps en structs.

Wanneer je de native uitvoeringsengine gebruikt, neem dan de volgende controles op in je regressietests:

Valideer het geheugengebruik waarbij de kolomsgewijze batchgrootte standaard toeneemt van 4.096 naar 10.240.
Vergelijk shuffleplannen en prestaties met de drempel voor sort-based columnar shuffle die daalt van 100.000 naar 4.000 partities.
Vergelijk resultaten van reguliere expressies en prestaties. Native-engine Java regex-ondersteuning verandert van uitgeschakeld naar ingeschakeld, en de instelling die alle regex-expressies terugvalt op Spark verandert van true naar false.

Apache Spark 4.1 standaardwaarden worden anders behouden in Fabric

Fabric Runtime 2.0 overschrijft opzettelijk de volgende Apache Spark 4.1-standaardinstellingen. Ga er niet van uit dat een upstream Spark 4.1-standaard ongewijzigd geldt in Fabric.

Configuration	Apache Spark 4.1 standaard	waarde van 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`

Spark SQL en DataFrame-gedrag

Spark 4.1 introduceert gedragsveranderingen die de resultaten van query's kunnen veranderen of ervoor kunnen zorgen dat eerder geaccepteerde query's falen. Let vooral op het gedrag van ANSI SQL, casts, datum- en tijdstempeloperaties, datatypes, JDBC-mappings en verouderde SQL-configuraties.

Voer regressietests uit om het volgende te vergelijken:

Outputschema's, inclusief type, precisie, schaal en nullability.
Rijtellingen en geaggregeerde resultaten.
Null, overflow, deling door nul en ongeldig cast-gedrag.
Datum, tijdstempel, tijdzone en intervalresultaten.
JDBC bron- en sinktype-mappingen.
Queryplannen en prestaties voor kritieke workloads.

Gebruik geen legacy-compatibiliteitsinstellingen als permanente migratiestrategie. Als je er tijdelijk een gebruikt om een storing te isoleren, werk dan de getroffen code bij en verwijder de instelling voordat je de migratie voltooit. Voor de volledige set gedragsveranderingen, zie de Spark SQL-migratiegids.

Python en pandas API op Spark

Runtime 2.0 verhuist van Python 3.11 naar Python 3.13 en bevat de PySpark-wijzigingen die in Spark 4.1 zijn geïntroduceerd. Spark 4.1 verhoogt ook het minimum aan ondersteunde versies van pandas, NumPy en PyArrow en verwijdert API's die in eerdere versies verouderd waren.

Veelvoorkomende pandas API-updates op Spark zijn onder andere:

Vervang DataFrame.iteritems en Series.iteritems door items.
Vervang DataFrame.append en Series.append door ps.concat.
Vervang verwijderde inplace argumenten bij categorische bewerkingen door toewijzingen.
Bekijk gewijzigde parameternamen en standaardinstellingen, zoals inclusive en Series.str.replace(regex=...).
Valideer resultaatkolomnamen, indexnamen, dtypes en volgorde.

Voor de volledige lijst, zie de PySpark-migratiegids.

Java- en Scala-toepassingen

Scala 2.13 is niet binair compatibel met Scala 2.12. Het hergebruiken van een Runtime 1.3 JAR in Runtime 2.0 kan class-loading fouten veroorzaken, zelfs als de broncode niet is veranderd. Bouw een apart Runtime 2.0-artefact en update alle cross-built afhankelijkheden van Scala.

Spark 4.1 verandert ook zijn interne servlet API-referenties van javax naar jakarta. Bekijk aangepaste listeners, Spark-extensies en bibliotheken die interactie hebben met interne onderdelen van Spark. Voor andere wijzigingen op engine-niveau, zie de Spark Core-migratiegids.

Streaming-workloads en connectoren

De verouderde EventHubConnector die in Runtime 1.3 is opgenomen, is niet beschikbaar in Runtime 2.0. Gebruik de Apache Spark Kafka-connector met het Kafka-compatibele eindpunt voor Azure Event Hubs. Voor installatierichtlijnen, zie Apache Spark gebruiken met Azure Event Hubs voor Apache Kafka.

Voor toepasbare scenario's kun je ook Fabric eventstream evalueren om streaminggegevens op te nemen en deze in een notebook te verwerken met Spark Structured Streaming. Voor meer informatie, zie Query eventstream in Microsoft Fabric vanuit een notebook met Spark Structured Streaming.

Voor elke gestructureerde streamingwerklast:

Test of de Runtime 2.0-query kan herstarten vanaf een kopie van het bestaande checkpoint.
Valideer stateful operations, event-time watermerken, triggers, bron- en sinkopties en outputschema's.
Houd de brongegevens en het oorspronkelijke controlepunt beschikbaar totdat de validatie is voltooid.
Als een checkpoint niet compatibel is, plan dan een gecontroleerde herstart met een nieuw checkpoint. Voorzie in de verwerking van opnieuw afgespeelde of overgeslagen input, en maak de sink idempotent voordat je opnieuw opstart.

Bekijk de Structured Streaming-migratiegids voor wijzigingen in upstream-compatibiliteit.

Delta Lake-tabellen

Delta Lake onderhoudt achterwaartse compatibiliteit voor bestaande tabellen, zodat Runtime 2.0 kan werken met tabellen die door Runtime 1.3 zijn gemaakt. Het inschakelen van een nieuwere tabelfunctie kan echter het lezers- of schrijverprotocol van de tabel verhogen en voorkomen dat oudere engines of andere Fabric-ervaringen de tabel gebruiken.

Tijdens de initiële runtime-migratie:

Upgrade geen tabelprotocollen en schakel geen Delta Lake 4.2-functies in.
Inspecteer de eigenschappen en protocolversies van nieuw aangemaakte tabellen evenals bestaande tabellen. Runtime 2.0 zet spark.databricks.delta.properties.defaults.enableDeletionVectors op true; verifieer de resulterende tabelmetadata in plaats van aan te nemen dat het vermijden van handmatige functie-inschakeling de compatibiliteit behoudt.
Leesbewerkingen testen, schrijfbewerkingen, samenvoegingen, schema-evolutie, onderhoudsoperaties en gelijktijdige toegang.
Identificeer elke engine die elke tabel leest of schrijft, inclusief het SQL-analyse-eindpunt, Power BI, pipelines, dataflows, eventstreams en externe engines.
Schakel een nieuwe Delta-functie pas in nadat alle gebruikers deze ondersteunen.

Delta Lake 4.2-specifieke functies zijn experimenteel in Fabric en beperkt tot Spark-ervaringen. Voor de ondersteuningsmatrix en standaardprotocolversies, zie Delta Lake table format interoperability.

Migreer uw workloads

Gebruik een gefaseerde migratie in plaats van direct de runtime van een productiewerkruimte te wijzigen.

1. Inventariseer je Runtime 1.3 workloads

Noteer de volgende informatie:

notebooks, Spark-taakdefinities, pipelines, planningen en afhankelijke items.
Omgevingstoewijzingen op werkruimte- en itemniveau.
Spark-configuraties, inclusief eventuele instellingen voor legacy-compatibiliteit.
Publieke, private en aangepaste bibliotheken en hun opgeloste versies.
Aangepaste JAR-bestanden, Python wheels, R-pakketten, native bibliotheken en initialisatielogica.
Databronnen, bestemmingen, secrets, verbindingen en netwerkvereisten.
Delta-tabellen en alle niet-Spark-gebruikers van die tabellen.
Streaming checkpoints, schema's, offsets en herstelvereisten.
Verwachte outputschema's, rijaantallen, datakwaliteitscontroles en prestatiebaselines.

Geef prioriteit aan workloads die gebruikmaken van aangepaste bibliotheken, native code, Scala, streaming state of geavanceerde Delta-functies.

2. Maak een Runtime 2.0-testomgeving

Maak een apart omgevingsitem aan en selecteer 2.0 (Spark 4.1, Delta 4.2) als runtime. Voeg de benodigde bibliotheken toe, sla de omgeving op en publiceer het. Koppel de omgeving aan kopieën van representatieve notitieboeken en Spark-taakdefinities in een ontwikkel- of testwerkruimte.

Als je productiewerkruimte nog steeds Runtime 1.3 gebruikt, verander dan de runtime niet totdat de test is voltooid. Houd de bestaande configuratie beschikbaar voor terugrol tijdens validatie.

Om aankomende Runtime 2.0-updates te valideren voordat ze het standaardkanaal bereiken, gebruik je het early access-releasekanaal in je testomgeving. Voor meer informatie, zie Fabric runtime release channels.

3. Bibliotheken en code bijwerken

Pas de wijzigingen toe die in de compatibiliteitsreview zijn geïdentificeerd:

Vervang ontbrekende ingebouwde pakketten door expliciete omgevingsafhankelijkheden.
Werk pakketten bij of vervang pakketten die geen Python 3.13, Java 21, Scala 2.13 of Azure Linux 3.0 ondersteunen.
Bouw aangepaste JAR-bestanden en native binaries opnieuw op.
Werk verwijderde PySpark- en pandas-API-op-Spark-aanroepen bij.
Vervang EventHubConnector door de Kafka-connector.
Verwijder Spark-instellingen voor configuraties die niet beschikbaar zijn in Runtime 2.0, en bekijk expliciete overrides van configuraties waarvan de standaardinstellingen zijn veranderd.
Los de gedragsverschillen van Spark SQL in code op in plaats van permanent te vertrouwen op legacy-instellingen.
Houd bestaande Delta-tabelfuncties en protocollen ongewijzigd tijdens deze fase.

4. Voer compatibiliteits- en regressietests uit

Voer dezelfde representatieve inputs uit op Runtime 1.3 en Runtime 2.0. Vergelijken:

Voltooiingsstatus, logs, waarschuwingen en herpogingen.
Schema's en datatypes.
Resultaten op rijniveau en geaggregeerde resultaten.
Geschiedenis en protocol van de Delta-tabel
Streamingvoortgang, status, latentie en afhandeling van duplicaten.
Uitvoeringstijd, resourcegebruik en kosten.
Resultaten in vervolgprocessen in het SQL-analyse-endpoint, Power BI, pipelines en andere consumenten.

Neem ook faal- en hersteltests op, niet alleen succesvolle runs. Het opnieuw opstarten van testsessies, nieuwe pogingen voor taken, checkpointherstel en gelijktijdige tabeltoegang.

5. Rol Runtime 2.0 uit

Verplaats werklasten in gecontroleerde batches:

Publiceer de gevalideerde Runtime 2.0-omgeving.
Koppel het aan een kleine set productienotebooks of Spark-jobdefinities.
Voer de batch uit en monitor de output en afnemende systemen.
Ga door met de resterende werklast na de observatieperiode.
Stel Runtime 2.0 pas als standaard voor de werkruimte in nadat de migratie op itemniveau is voltooid.

Het wijzigen van de workspace-runtime beïnvloedt nieuwe Spark-sessies. Bestaande sessies blijven hun huidige runtime gebruiken totdat ze stoppen.

6. Zorg voor een rollbackpad

Houd de Runtime 1.3-omgeving, artefacten, bibliotheekspecificaties en streamingcontrolepunten totdat de Runtime 2.0-observatieperiode eindigt. Om terug te rollen, sluit je de Runtime 1.3-omgeving opnieuw aan of herstel je de vorige werkruimte-runtime en start je een nieuwe Spark-sessie.

Important

Een Delta-protocolupgrade is over het algemeen niet omkeerbaar. Schakel tabelfuncties die het protocol verhogen niet in totdat je Runtime 2.0-validatie hebt voltooid en compatibiliteit met elke tabelconsument hebt bevestigd.

Controlelijst voor migratie

Bevestig voordat je de migratie voltooit dat:

[ ] Elk vereiste Python- en R-pakket is expliciet beschikbaar en compatibel met Python 3.13 of R 4.5.
[ ] Aangepaste JAR-bestanden richten zich op Java 21, Scala 2.13 en Spark 4.1.
[ ] Native afhankelijkheden werken op Azure Linux 3.0.
[ ] Werkruimte-, omgevings-, notitieboek- en Spark-taakdefinitie-instellingen gebruiken geen verwijderde Spark-configuraties.
[ ] Workloads worden getest aan de hand van de gewijzigde Runtime 2.0 Spark-configuratiestandaardinstellingen.
[ ] Spark SQL en PySpark regressietests slagen.
[ ] De werklasten van Event Hubs gebruiken de Kafka-connector.
[ ] Structured Streaming-workloads herstarten en herstellen zoals bedoeld.
[ ] Delta-tabel protocollen en functies blijven compatibel met alle consumenten.
[ ] Datakwaliteit, prestaties en kostenresultaten voldoen aan uw acceptatiecriteria.
[ ] Productie-uitrol, monitoring en terugrollprocedures worden gedocumenteerd en getest.

Feedback

Is deze pagina nuttig?

Laatst bijgewerkt om 2026-10-23