Intelligentes Sharding in Device Run auf der Developer Device Platform

Mit Smart Sharding in Developer Device Platform Device Run werden Android-Instrumentierungstests und iOS-XCTests auf parallele Shards verteilt. Dazu werden historische Testausführungszeiten verwendet, die in Cloud Storage gespeichert sind. Im Gegensatz zum einheitlichen Sharding, bei dem Testfälle unabhängig von der Laufzeit der einzelnen Tests nach Anzahl aufgeteilt werden, werden beim intelligenten Sharding die Shards nach der erwarteten Dauer ausgeglichen, sodass parallele Shards ungefähr zur gleichen Zielzeit abgeschlossen werden.

In diesem Dokument wird erläutert, wie der intelligente Sharding-Algorithmus die Anzahl der Shards berechnet und Tests zuweist. Außerdem wird das Schema des YAML-Timing-Datensatzes beschrieben, der in Ihrem Cloud Storage-Bucket gespeichert ist. Außerdem werden häufige Fragen zum Overhead des Android Test Orchestrators und zum rollierenden 30-Tage-Datenfenster beantwortet. Eine Anleitung für die Befehlszeile mit der Google Cloud CLI finden Sie in der Anleitung für Android-Instrumentierung und iOS-XCTest.

Funktionsweise des intelligenten Fragmentierungsalgorithmus

Fragmentierung ist nicht gleichbedeutend mit der Anzahl der Tests, die gleichzeitig ausgeführt werden können. Es ist möglich, dass zum Zeitpunkt der Anfrage weniger Geräte verfügbar sind als das Shard-Limit. Die tatsächliche Anzahl gleichzeitiger Geräte, die einem Nutzer zugewiesen werden können, kann niedriger sein als die von ihm angegebene Anzahl von Shards.

Wenn Sie eine Sitzung mit --sharding-option=smart in der gcloud CLI senden oder smartSharding in der REST API konfigurieren, führt die Developer Device Platform einen sechsstufigen Workflow aus, der die Sitzungserstellung, die Testausführung und den Abschluss umfasst:

  1. Lesen Sie historische Zeitdaten und gleichen Sie sie mit dem Gerätekontext ab. Bevor Shards geplant werden, liest der Device Run-Dienst-Agent Ihre YAML-Datei für das Smart Sharding aus Cloud Storage. In der Liste records wird nach einem shardingContext gesucht, das mit dem deviceModel und der osVersion des Zieljobs übereinstimmt (Groß-/Kleinschreibung wird nicht berücksichtigt). Wenn für diese Kombination aus Gerät und Betriebssystem keine genaue Übereinstimmung vorhanden ist, greift die Developer Device Platform auf den ersten verfügbaren records-Eintrag in der Datei zurück. Wenn die YAML-Datei noch nicht vorhanden ist, wird die Sitzung als Kaltstart mit leerem Zeitverlauf fortgesetzt.
  2. Filtert die Stichproben auf das rollierende 30-Tage-Zeitfenster und berechnet die erwarteten Dauern. Für den ausgewählten Kontextdatensatz behält die Developer Device Platform nur Zeitstichproben bei, deren recordTime innerhalb der letzten 30 Tage liegt, und berechnet die arithmetische mittlere Dauer für jeden Testfall. Wenn Android Test Orchestrator mit --orchestrator-version aktiviert ist, berechnet die Developer Device Platform auch den 30-Tage-Mittelwert der ANDROID_TEST_ORCHESTRATOR-Overhead-Stichproben und fügt diesen durchschnittlichen Overhead zur erwarteten Dauer jedes Testlaufs hinzu.
  3. Ausführbare Tests ermitteln und Fallback-Schätzungen zuweisen Auf dem Worker-Host prüft die Developer Device Platform Ihr Testpaket statisch. Dabei werden DEX-Dateien im Test-APK unter Android oder kompilierte .xctest-Symbole und .xctestrun-Filter unter iOS gelesen. Außerdem werden alle --test-targets-Filter angewendet und ignorierte oder unterdrückte Tests (z. B. @Ignore oder @Suppress) ausgeschlossen. Jede ausführbare Testeinheit erhält eine erwartete Dauer, die auf drei Stufen basiert:
    • Aufgezeichneter Testfall: Verwendet die durchschnittliche Dauer der letzten 30 Tage (plus den durchschnittlichen Orchestrator-Overhead, wenn Android Test Orchestrator aktiviert ist). Unter Android werden parametrisierte JUnit-Klassen (z. B. Klassen, die @RunWith(Parameterized.class), JUnitParamsRunner oder TestParameterInjector verwenden) als einzelne Einheit auf Klassenebene geplant, deren erwartete Dauer die Summe aller aufgezeichneten Methodendauern für diese Klasse ist.
    • Nicht aufgezeichneter Testlauf in einer vorhandenen Suite: Verwendet die durchschnittliche erwartete Dauer aller aufgezeichneten Testläufe mit einem Wert ungleich null im übereinstimmenden Datensatz.
    • Kaltstart (kein aufgezeichneter Verlauf): Es wird eine Standardschätzung von 30 Sekunden pro Testeinheit verwendet.
  4. Shard-Anzahl berechnen Die Developer Device Platform summiert die erwarteten Dauern aller ausführbaren Testeinheiten und teilt sie durch den von Ihnen konfigurierten --smart-sharding-target-duration (gültig von 2m bis 1h). Das Ergebnis wird auf den nächsten ganzen Shard aufgerundet:

    optimal_shards = max(1, ceil(total_expected_duration / target_duration))
    

    Als Nächstes legt die Developer Device Platform die endgültige Shard-Anzahl zwischen 1 und dem niedrigsten der folgenden Limits fest:

    • Die Gesamtzahl der ausführbaren Testeinheiten (verhindert leere Shards).
    • Der Wert für --smart-sharding-max-shard-count, wenn er größer als 0 ist.
    • Das Plattformlimit (20 Shards für physische Geräte oder 200 Shards für virtuelle Android-Geräte).
  5. Tests mit Bin-Packing nach dem Prinzip „Längste Verarbeitungszeit zuerst“ zuweisen. Die Developer Device Platform sortiert alle ausführbaren Testeinheiten in absteigender Reihenfolge der erwarteten Dauer (von der langsamsten zur schnellsten) und initialisiert einen Min-Heap leerer Shards, sortiert nach der akkumulierten Dauer. Dabei wird jeweils eine Testeinheit genommen und der langsamste verbleibende Test dem Shard mit der geringsten kumulierten Dauer zugewiesen. Anschließend wird die Gesamtdauer dieses Shards aktualisiert. Wenn Sie langsame Tests zuerst planen, werden sie auf separate Shards isoliert, während kürzere Tests die verbleibenden Lücken füllen, um die Gesamtdauer der Shards auszugleichen.

  6. Zeiten für das Passieren erfassen und Cloud Storage aktualisieren. Nachdem alle Shards abgeschlossen sind, erfasst die Developer Device Platform die gemessenen Dauern von startTime bis endTime für erfolgreiche Testläufe, entfernt alle Stichproben, die älter als 30 Tage sind, aus allen Gerätekontexten in der YAML-Datei, entfernt alle Kontextdatensätze, die keine gültigen Stichproben mehr enthalten, und schreibt die aktualisierte YAML-Datei mithilfe von optimistischen Nebenläufigkeitswiederholungen mit Generationsabgleich zurück in Cloud Storage.

YAML-Dateistruktur für Smart Sharding

Wenn Sie eine Sitzung mit der gcloud CLI ausführen, gibt --smart-sharding-record-name den Basisdateinamen (ohne die YAML-Erweiterung) des Zeitdatensatzes an, der im Cloud Storage-Bucket Ihres Google Cloud -Projekts gespeichert ist:

gs://BUCKET_NAME/automation/smart-sharding/RECORD_NAME.yaml

Ersetzen Sie die folgenden Platzhalter:

  • BUCKET_NAME: der mit --bucket-name angegebene Cloud Storage-Bucket-Name oder standardmäßig <var>PROJECT_ID</var>-devicerun (wobei PROJECT_ID Ihre Google Cloud-Projekt-ID ist).
  • RECORD_NAME: die Datensatz-ID, die an --smart-sharding-record-name übergeben wird, ohne die YAML-Dateiendung (z. B. wird checkout-suite zu automation/smart-sharding/checkout-suite.yaml zugeordnet).

Beispiel für einen YAML-Timing-Eintrag

Das folgende Beispiel zeigt eine YAML-Datei für Smart Sharding (checkout-suite.yaml) mit Zeitaufzeichnungen für zwei Gerätekontexte: ein Android-Gerät, das mit Android Test Orchestrator ausgeführt wird, und ein iOS-Gerät:

records:
- shardingContext:
    deviceModel: shiba
    osVersion: '34'
  testCaseTimingRecords:
  - testCaseName: com.example.shop.CheckoutTest#testCompletePurchase
    timingSamples:
    - duration: 42.180s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 44.050s
      recordTime: '2026-11-09T16:45:03Z'
  - testCaseName: com.example.shop.CartTest#testApplyPromoCode
    timingSamples:
    - duration: 8.600s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 9.120s
      recordTime: '2026-11-09T16:45:03Z'
  conditionalOverheads:
  - condition: ANDROID_TEST_ORCHESTRATOR
    timingSamples:
    - duration: 2.850s
      recordTime: '2026-11-08T14:20:11Z'
    - duration: 3.150s
      recordTime: '2026-11-09T16:45:03Z'
- shardingContext:
    deviceModel: iphonese3
    osVersion: '18.4'
  testCaseTimingRecords:
  - testCaseName: ShopTests.CheckoutTests#testApplePaySheet
    timingSamples:
    - duration: 19.340s
      recordTime: '2026-11-09T17:10:29Z'

Referenz zu YAML-Feldern

In der YAML-Datei für intelligentes Sharding wird das SuiteTiming-Schema mit camelCase-Feldnamen serialisiert. In der folgenden Tabelle werden die einzelnen Felder in der Datei beschrieben:

Feld Typ Beschreibung
metadata Karte (string bis string) Optionale Schlüssel/Wert-Metadaten auf Suite-Ebene, die bei Aggregationsaktualisierungen beibehalten werden.
records Liste der Objekte Zeiteinträge pro Gerät (SuiteTimingWithContext), partitioniert nach Hardwaremodell und Betriebssystemversion.
records[].shardingContext Objekt Hardware- und Betriebssystemdimensionen, die einen Satz von Zeitmessungen umfassen.
records[].shardingContext.deviceModel string Modellkennung des Geräts, auf dem die Zeiten aufgezeichnet wurden (z. B. shiba unter Android oder iphonese3 unter iOS).
records[].shardingContext.osVersion string Betriebssystem- oder SDK-Version des Geräts (z. B. Android API-Level '34' oder iOS-Version '18.4')
records[].testCaseTimingRecords Liste der Objekte Vergangene Ausführungsdauern für einzelne bestandene Testläufe in diesem Kontext.
records[].testCaseTimingRecords[].testCaseName string Vollständig qualifizierte Test-ID im Format package.ClassName#methodName (oder package.ClassName, wenn keine Methodenmetadaten vorhanden sind).
records[].testCaseTimingRecords[].timingSamples Liste der Objekte Rollierende 30-Tage-Liste der gemessenen Dauern für den Testfall, die nach erfolgreichen Ausführungen angehängt wird.
timingSamples[].duration Dauerstring Gemessene Dauer, formatiert in Sekunden mit optionaler Genauigkeit (z. B. 10s oder 42.180s).
timingSamples[].recordTime Zeitstempelstring RFC 3339-UTC-Zeitstempel, der angibt, wann die Developer Device Platform die Stichprobe aufgezeichnet hat (z. B. '2026-11-09T16:45:03Z').
records[].conditionalOverheads Liste der Objekte Optionale Ausführungsoverheads, die unter bestimmten Runner-Modi gemessen werden, beschränkt auf shardingContext. Wird weggelassen, wenn keine bedingten Overheads anfallen.
records[].conditionalOverheads[].condition string Kennung für die Ausführungsbedingung. Unterstützter Wert: ANDROID_TEST_ORCHESTRATOR.
records[].conditionalOverheads[].timingSamples Liste der Objekte Fortlaufende 30-Tage-Liste der Overhead-Stichproben pro Übergang, die von qualifizierten Shards aufgezeichnet wurden.

ANDROID_TEST_ORCHESTRATOR-Overhead-Zeiten verstehen

Wenn Sie Android-Instrumentierungstests mit --orchestrator-version ausführen, enthält die YAML-Datei für Smart Sharding einen conditionalOverheads-Eintrag mit condition: ANDROID_TEST_ORCHESTRATOR. Im Gegensatz zu testCaseTimingRecords sind diese Overhead-Stichproben nicht an eine einzelne Testmethode oder einen nummerierten Shard angehängt.

Was eine Stichprobe der Overhead-Dauer darstellt

Wenn Android Test Orchestrator aktiviert ist, wird jede Testmethode in einem eigenen isolierten Instrumentation-Prozess ausgeführt. Die Zeitstempel für den startTime und endTime einzelner Tests erfassen nur die Zeit, die innerhalb der jeweiligen Testmethode verbracht wird. Sie enthalten nicht die Zeit zwischen den Tests, die für das Beenden des vorherigen App-Prozesses, das optionale Löschen von Paketdaten (clearPackageData) und das Starten eines neuen Instrumentation-Prozesses für den nächsten Test aufgewendet wird.

Um diese Übergangskosten zwischen Tests zu messen, prüft die Developer Device Platform jeden erfolgreichen Shard, der zwei oder mehr Testläufe ausführt (N > 1), und berechnet Folgendes:

  1. Gesamte Shard-Ausführungsdauer: Die verstrichene Zeit vom frühesten Test startTime im Shard bis zum spätesten Test endTime im Shard.
  2. Gesamtdauer des Testlaufs: die Summe von (endTime - startTime) für alle N Testläufe in diesem Shard.
  3. Durchschnittlicher Overhead pro Übergang: Da N sequenzielle Tests N - 1 Übergänge zwischen Tests haben, subtrahiert die Developer Device Platform die Summe der Testdauern von der Shard-Spanne und dividiert durch N - 1:

    overhead_sample = max(0, total_span - total_test_duration) / (N - 1)
    

Jeder bestandene Shard mit mehreren Tests in Ihrem Job trägt einen TimingSample zu ANDROID_TEST_ORCHESTRATOR bei. Wenn eine Sitzung beispielsweise über drei Shards ausgeführt wird und jeder Shard mindestens zwei Testfälle besteht, werden dieser Sitzung drei Overhead-Stichproben mit der recordTime der Sitzung angehängt. Shards, die nur einen einzigen Testfall (N = 1) ausführen, haben keine Übergänge zwischen Tests und geben keine Overhead-Stichprobe aus.

Warum der Overhead nicht mit einem Testlauf oder Shard verknüpft ist

Die Developer Device Platform speichert ANDROID_TEST_ORCHESTRATOR-Stichproben auf der Ebene shardingContext (deviceModel und osVersion) und nicht pro Test oder Shard. Das hat zwei Gründe:

  • Der Overhead hängt vom Gerät und vom Betriebssystem ab, nicht von der Testlogik. Das Starten des Prozesses, die Binder-Initialisierung und das Löschen von Paketdaten dauern ungefähr gleich lang, unabhängig davon, welche JUnit-Methode als Nächstes ausgeführt wird. Shard-Gruppierungen ändern sich jedoch dynamisch, wenn sich die Testzeiten oder die Anzahl der Shards ändern.
  • Durch die Trennung des Overheads bleiben die Zeiten für den Baseline-Test sauber. Wenn Sie den Aufwand für die Prozessisolation aus testCaseTimingRecords heraushalten, können Sie --orchestrator-version für alle Ausführungen aktivieren oder deaktivieren, die denselben YAML-Eintrag verwenden, ohne die zugrunde liegenden Testausführungsdauern pro Test zu verfälschen.

Verwendung von Overhead durch die Developer Device Platform bei der Shard-Zuweisung

Wenn --orchestrator-version für eine neue Sitzung festgelegt ist, berechnet die Developer Device Platform den 30-Tage-Durchschnitt der gültigen ANDROID_TEST_ORCHESTRATOR-Stichproben (avg_overhead) und fügt ihn der durchschnittlichen 30-Tage-Dauer jedes Testfalls hinzu, bevor die Shard-Anzahl berechnet oder Shards gepackt werden:

expected_test_duration = avg_test_duration + avg_overhead

Wenn --orchestrator-version für die Sitzung nicht festgelegt ist, ist avg_overhead 0s und alle vorhandenen ANDROID_TEST_ORCHESTRATOR-Einträge in der YAML-Datei werden für diese Ausführung ignoriert.

Wenn Sie jedem Testfall avg_overhead hinzufügen, wirkt sich das auf drei Arten auf das Sharding aus:

  • Genaue Shard-Anzahl für Suites mit vielen schnellen Tests. Angenommen, Sie haben eine Suite mit 60 Instrumentierungstests im Unit-Stil, die jeweils in 1s ausgeführt werden, mit einem durchschnittlichen Orchestrator-Übergangs-Overhead von 3s und einer Ziel-Shard-Dauer von 2m (120s). Ohne Overhead beträgt die erwartete Gesamtdauer 60s. Alle 60 Tests werden also in 1 Shard gepackt, dessen Ausführung tatsächlich fast vier Minuten dauert (60s für die Testausführung plus 59 * 3s = 177s für Orchestrator-Übergänge). Durch Hinzufügen des 3s-Overheads zu jedem Test (4s erwartete Dauer pro Test oder 240s insgesamt) weist die Developer Device Platform 2 Shards (ceil(240s / 120s)) zu, sodass jeder Shard ungefähr das Ziel von zwei Minuten erreicht.
  • Ausgewogenes Shard-Packing bei unterschiedlicher Anzahl von Tests. Beim Bin-Packing nach dem Prinzip „Längste Verarbeitungszeit zuerst“ fallen für einen Shard, dem ein 40s-UI-Test zugewiesen ist, 43s der erwarteten Kosten (40s + 3s) an, während für einen Shard, dem zehn 4s-Tests zugewiesen sind, 70s der erwarteten Kosten (10 * (4s + 3s)) anfallen. Durch die Einbeziehung des Overheads pro Test wird verhindert, dass Shards mit vielen kurzen Tests unbemerkt Minuten an nicht gezählter Latenz für den Neustart des Prozesses ansammeln.
  • Realistische Schätzungen für neu hinzugefügte Tests. Da nicht aufgezeichnete Tests in einer vorhandenen Suite die durchschnittliche erwartete Dauer bekannter Tests übernehmen, die bereits avg_overhead enthält, berücksichtigen neue Tests den Orchestrator-Overhead automatisch bei ihrer ersten Ausführung.

30-tägiges Datenfenster und Verhalten bei der ersten Ausführung

Für das intelligente Sharding sind keine 30 Tage an Verlaufsdaten erforderlich, bevor die Optimierung Ihrer Testläufe beginnt. Selbst ein einzelnes aufgezeichnetes Sample aktiviert die dauerbasierte Shard-Berechnung und das Bin-Packing in der nächsten Sitzung. Stattdessen sind 30 Tage das fortlaufende Aufbewahrungs- und Lookback-Window, das die Developer Device Platform beim Lesen und Aktualisieren des YAML-Timing-Datensatzes verwendet.

Warum beim Smart Sharding ein rollierendes 30-Tage-Zeitfenster verwendet wird

Jedes Mal, wenn die Developer Device Platform eine YAML-Datei für Smart Sharding liest oder aktualisiert, werden alle TimingSample herausgefiltert, deren recordTime älter als 30 Tage ist. Dieses 30-tägige Zeitfenster ist ein Kompromiss zwischen zwei technischen Zielen:

  • Anpassung an Änderungen der Codebasis und Begrenzung der Dateigröße. App-Funktionen, UI-Abläufe und Testimplementierungen entwickeln sich im Laufe der Zeit weiter. Durch das automatische Entfernen von Stichproben, die älter als 30 Tage sind, wird verhindert, dass veraltete Zeitangaben, z. B. Zeitangaben vor einer Neugestaltung des Bildschirms oder einer Refaktorierung der Netzwerkschicht, die aktuellen Shard-Zuweisungen verfälschen. Durch das Entfernen abgelaufener Einträge (und das Löschen von Gerätekontexten, die keine gültigen Beispiele mehr haben) bleibt die YAML-Datei kompakt und weit unter dem Limit von 32 MB.
  • Glättung der Varianz zwischen den Ausführungen bei gleichzeitiger Unterstützung wöchentlicher Suites. Bei einem einzelnen Testlauf kann es zu vorübergehenden Störungen durch die automatische Speicherbereinigung, Hintergrundsystemdienste oder die Emulatorplanung kommen. Durch die Mittelwertbildung der Stichproben über einen Zeitraum von 30 Tagen werden einmalige Spitzen geglättet, während gleichzeitig genügend Verlaufsinformationen erhalten bleiben, sodass nächtliche, wöchentliche oder Sprint-basierte Continuous-Integration-Pipelines zwischen den Ausführungen aktuelle Zeitmessungen beibehalten.

Was dich in Woche 1 und 2 erwartet

Wenn Sie Smart Sharding heute für eine vorhandene Test-Suite aktivieren, folgen die Ausführungszeiten einer schnellen Warm-up-Kurve, anstatt dass es Wochen dauert, bis sie sich verbessern:

  1. Erste Ausführung (Kaltstart). Da die YAML-Datei noch nicht in Cloud Storage vorhanden ist, weist die Developer Device Platform jeder ausführbaren Testeinheit die Standard-Schätzung von 30 Sekunden zu. Die Anzahl der Shards wird als ceil(num_tests * 30s / target_duration) berechnet (begrenzt durch die maximale Anzahl von Shards und Plattformlimits) und die Tests werden auf die Shards verteilt, ähnlich wie beim einheitlichen Sharding. Bei dieser ersten Ausführung:
    • Wenn Ihre Tests im Durchschnitt deutlich weniger als 30 Sekunden dauern, werden in Ausführung 1 möglicherweise mehr Shards als nötig zugewiesen (bis zu --smart-sharding-max-shard-count).
    • Wenn Ihre Suite mehrere UI-Tests enthält, die mehrere Minuten dauern, können zwei langsame Tests zufällig im selben Shard landen, sodass dieser Shard zum Engpass für die Fertigstellungszeit wird.
    • Wenn Ausführung 1 abgeschlossen ist, erstellt die Developer Device Platform die YAML-Datei in Cloud Storage mit den gemessenen Dauern Ihrer bestandenen Tests.
  2. Zweite Ausführung (unmittelbar nach Abschluss von Ausführung 1). Smart Sharding ist bereits aktiv. Die Developer Device Platform liest die von Durchlauf 1 aufgezeichneten Dauern, berechnet die Shard-Anzahl anhand der tatsächlichen Ausführungszeit Ihrer Suite neu und isoliert die langsamsten Tests zuerst auf separaten Shards. Die primäre Reduzierung der Sitzungsdauer und die richtige Dimensionierung der Shard-Anzahl sind in der Regel ab Ausführung 2 zu sehen – sogar am selben Tag, an dem Sie Smart Sharding aktivieren.
  3. Rest der ersten Woche und zweite Woche In den nächsten Durchläufen wird die Shard-Balance in drei spezifischen Fällen weiter optimiert:
    • Glättung der Varianz einzelner Ausführungen Da bei jedem Durchlauf ein weiterer TimingSample angehängt wird, werden vorübergehende Schwankungen aus Durchlauf 1 ausgeglichen. Dadurch werden Nachzügler-Shards reduziert, die etwas nach --smart-sharding-target-duration abgeschlossen werden.
    • Tests aus anfänglich fehlgeschlagenen Ausführungen werden ausgefüllt. Damit schnelle Abstürze oder Testzeitüberschreitungen die historischen Durchschnittswerte nicht verfälschen, zeichnet die Developer Device Platform nur die Zeiten für bestandene Tests auf (und unter Android nur für Shards, deren Gesamtstatus „PASSED“ ist). Für alle Tests, für die in Durchlauf 1 keine Zeit aufgezeichnet wurde, wird in Durchlauf 2 die durchschnittliche Dauer der Suite verwendet. Sobald der Test bestanden ist, wird die gemessene Zeit verwendet.
    • Neue Tests oder Gerätemodelle hinzufügen Für alle neuen Testläufe, die in den ersten beiden Wochen durchgeführt werden, wird automatisch die durchschnittliche erwartete Dauer der Suite verwendet, anstatt auf den Standardwert von 30 Sekunden zurückzugreifen. Wenn Sie der Sitzung ein zweites --device-Modell mit demselben Aufzeichnungsnamen hinzufügen, werden beim ersten Durchlauf die Zeiten des vorhandenen Geräts als anfänglicher Fallback verwendet. Anschließend wird ein dedizierter shardingContext-Eintrag für nachfolgende Durchläufe aufgezeichnet.

Häufig gestellte Fragen

Die folgenden Fragen decken gängige Betriebsszenarien bei der Ausführung von Smart Sharding in CI/CD-Pipelines ab.

Nächste Schritte