Feature-Views mit deklarativen Automatisierungsbündeln bereitstellen

Important

Dieses Feature befindet sich in der privaten Vorschauphase. Wenden Sie sich an Ihren Azure Databricks-Kontakt, um es zu testen.

Deklarative Automatisierungsbündel (früher bekannt als Databricks Asset Bundles) ermöglichen es Ihnen, Azure Databricks-Ressourcen wie Feature Views und die damit verbundenen Endpunkte programmatisch zu validieren, bereitzustellen und auszuführen. Erfahren Sie , was deklarative Automatisierungspakete sind?.

Dieses Tutorial erstellt ein Bundle, das zwei Streaming-Feature-Views deklariert, sie in einem Online-Shop materialisiert und sie über einen FeatureSpec Feature Serving-Endpunkt bereitstellt. Dann rufen Sie den Endpunkt ab, ändern, welche Features er bereitstellt, und bauen alles wieder ab.

Die Feature Views und ihre Materialisierung werden in „Manage Feature Views using Declarative Automation Bundles“ beschrieben, in dem sie im Detail erklärt werden. Um stattdessen ein FeatureSpec und einen Endpunkt mit der Python-API zu erstellen, siehe Feature Views servieren nach.

Jeder Schritt zeigt die Konfiguration sowohl in YAML als auch in Python. Wähle eine Sprache und die Seite wird entsprechend deiner Auswahl angezeigt.

Requirements

Um dieses Tutorial abzuschließen, benötigen Sie Folgendes:

Ressourcen in einem Bündel bereitstellen

Ein Bundle stellt Feature Views über zwei Ressourcentypen bereit:

  • FeatureSpec: eine Unity-Katalogfunktion, die die bereitzustellenden Features auflistet. Es enthält keine Feature-Werte. Ein Endpunkt, der sie bereitstellt, liest diese aus den Online-Tabellen aus, auf die die Feature Views materialisiert werden. Siehe Features mit einem FeatureSpec bereitstellen und für die Konfigurationsreferenz feature_spec.
  • Feature Serving Endpoint: ein Model Serving Endpoint, der ein FeatureSpec anstelle eines Modells bereitstellt. Ein Bundle deklariert es als Ressource model_serving_endpoints . Zur Konfigurationsreferenz siehe model_serving_endpoint.

Feature Views aus einem Bundle bereitstellen

Mit den folgenden Schritten erstellen und stellen Sie das Bundle bereit, fragen den Endpunkt ab, ändern, was es ausliefert, und räumen auf.

Authentifizierung einrichten

Richte zuerst die Authentifizierung zwischen der Databricks-CLI auf deinem Entwicklungsrechner und deinem Azure Databricks-Arbeitsbereich ein. Bei dieser Seite wird davon ausgegangen, dass Sie die OAuth-Authentifizierung User-to-Machine (U2M) und ein entsprechendes Azure Databricks-Konfigurationsprofil namens DEFAULT für die Authentifizierung verwenden möchten.

Note

Die U2M-Authentifizierung eignet sich für das Testen dieser Schritte in Echtzeit. Bei vollständig automatisierten Workflows empfiehlt Databricks stattdessen die Verwendung der OAuth-M2M-Authentifizierung (Machine-to-Machine, Computer-zu-Computer). Lesen Sie die Anweisungen zum Einrichten der M2M-Authentifizierung unter Autorisieren des Dienstprinzipalzugriffs auf Azure Databricks mit OAuth.

  1. Verwenden Sie die Databricks CLI, um die OAuth-Tokenverwaltung lokal zu initiieren, indem Sie den folgenden Befehl für jeden Zielarbeitsbereich ausführen.

    Ersetzen Sie <workspace-url> im folgenden Befehl durch Ihre arbeitsbereichsspezifische Azure Databricks-URL, z. B. https://adb-1234567890123456.7.azuredatabricks.net.

    databricks auth login --host <workspace-url>
    
  2. Die Databricks-CLI fordert Sie auf, die von Ihnen eingegebenen Informationen als Azure Databricks-Konfigurationsprofil zu speichern. Drücken Sie Enter, um den vorgeschlagenen Profilnamen zu übernehmen, oder geben Sie den Namen eines neuen oder bereits vorhandenen Profils ein. Ist bereits ein Profil mit dem gleichen Namen vorhanden, wird es mit den von Ihnen eingegebenen Informationen überschrieben. Sie können Profile verwenden, um Ihren Authentifizierungskontext schnell über mehrere Arbeitsbereiche hinweg zu wechseln.

    Verwenden Sie zum Abrufen einer Liste vorhandener Profile in einem separaten Terminal oder einer separaten Eingabeaufforderung die Databricks CLI, um den Befehl databricks auth profiles auszuführen. Um die vorhandenen Einstellungen eines bestimmten Profils anzuzeigen, führen Sie den Befehl databricks auth env --profile <profile-name>aus.

  3. Führen Sie in Ihrem Webbrowser die Anweisungen auf dem Bildschirm aus, um sich bei Ihrem Azure Databricks-Arbeitsbereich anzumelden.

  4. Um den aktuellen OAuth-Tokenwert eines Profils und den bevorstehenden Ablaufzeitstempel eines Profils anzuzeigen, führen Sie einen der folgenden Befehle aus:

    • databricks auth token --host <workspace-url>
    • databricks auth token -p <profile-name>
    • databricks auth token --host <workspace-url> -p <profile-name>

    Wenn Sie über mehrere Profile mit demselben --host-Wert verfügen, müssen Sie möglicherweise die Optionen --host und -p zusammen angeben, damit die Databricks CLI die richtigen übereinstimmenden Informationen des OAuth-Tokens ermitteln kann.

Bundle erstellen

Erstelle ein leeres Verzeichnis für das Bundle, mit einer databricks.yml Datei an der Wurzel und einem resources Verzeichnis daneben.

YAML

Jeder der folgenden Schritte fügt eine Datei unter resources/ hinzu:

databricks.yml
resources/
  streaming_features.yml
  feature_spec.yml
  serving_endpoint.yml

databricks.yml enthält den Bündelnamen, den include Eintrag, der jede Datei unter resources/lädt, und die Variablen, auf die die Ressourcen verweisen:

bundle:
  name: feature-serving-quickstart

include:
  - resources/*.yml

variables:
  catalog:
    description: The catalog that the Feature Views and the FeatureSpec are written to.
    default: main
  schema:
    description: The schema that the Feature Views and the FeatureSpec are written to.
    default: features_demo
  stream:
    description: The three-level name of a Stream registered in Unity Catalog.
    default: main.features_demo.events
  online_store:
    description: The online store that serves the features.
    default: my_online_store
  endpoint_name:
    description: The name of the Feature Serving endpoint.
    default: event-features

Python

In Python deklarierte Ressourcen werden nur durch die python Abbildung in databricks.ymlgefunden. Ohne sie validiert und deployt das Bundle erfolgreich, enthält aber keine Ressourcen, also fügen Sie es jetzt hinzu:

bundle:
  name: feature-serving-quickstart

python:
  venv_path: .venv
  resources:
    - 'resources:load_resources'

variables:
  catalog:
    description: The catalog that the Feature Views and the FeatureSpec are written to.
    default: main
  schema:
    description: The schema that the Feature Views and the FeatureSpec are written to.
    default: features_demo
  stream:
    description: The three-level name of a Stream registered in Unity Catalog.
    default: main.features_demo.events
  online_store:
    description: The online store that serves the features.
    default: my_online_store
  endpoint_name:
    description: The name of the Feature Serving endpoint.
    default: event-features

Erstellen Sie das Projekt und seine virtuelle Umgebung und fügen Sie das Paket hinzu:

uv init --bare
uv venv .venv
uv add databricks-bundles

Erzeugen Sie resources/__init__.py mit der Funktion, die databricks.yml benennt:

from databricks.bundles.core import Bundle, Resources


def load_resources(bundle: Bundle) -> Resources:
    resources = Resources()
    # The following steps add resources here.
    return resources

Deklarieren Sie die Feature Views und deren Materialisierung

Beide Feature Views lesen denselben Stream und aggregieren pro Schlüssel über die letzten 90 Minuten. events_90m zählt Ereignisse, und amount_sum_90m summiert value.amount. Ein Materialisierungsset schreibt im Streaming-Modus in den Online-Store. Die Bedeutung jedes Konfigurationsschlüssels finden Sie unter Schritt 4 des Tutorials zu Feature Views.

Eine Streaming-Feature-Ansicht adressiert eine Eingabespalte als Pfad in den Stream-Eintrag. Ersetzen Sie daher überall dort, wo in den Beispielen value.* steht, die Namen durch die, die das Schema Ihres Streams verwendet.

YAML

Erstellen Sie resources/streaming_features.yml:

resources:
  features:
    events_90m:
      full_name: ${var.catalog}.${var.schema}.events_90m
      description: Events per key over a trailing 90 minutes
      source:
        stream_source:
          full_name: ${var.stream}
      function:
        aggregation_function:
          count_function:
            input: value.amount
          time_window:
            rolling:
              window_duration: 5400s
      entities:
        - name: value.key
      timeseries_column:
        name: value.event_timestamp

    amount_sum_90m:
      full_name: ${var.catalog}.${var.schema}.amount_sum_90m
      description: Sum of amount per key over a trailing 90 minutes
      source:
        stream_source:
          full_name: ${var.stream}
      function:
        aggregation_function:
          sum:
            input: value.amount
          time_window:
            rolling:
              window_duration: 5400s
      entities:
        - name: value.key
      timeseries_column:
        name: value.event_timestamp

  materialization_sets:
    serving_online:
      materialized_features:
        - feature_name: ${resources.features.events_90m.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: serving_online
          streaming_mode:
            mode: STREAMING_MODE_TYPE_RTM
        - feature_name: ${resources.features.amount_sum_90m.full_name}
          online_store_config:
            online_store_name: ${var.online_store}
            catalog_name: ${var.catalog}
            schema_name: ${var.schema}
            table_name_prefix: serving_online
          streaming_mode:
            mode: STREAMING_MODE_TYPE_RTM

Python

Füge die Importe zu resources/__init__.py hinzu:

from databricks.bundles.features import (
    AggregationFunction,
    CountFunction,
    DataSource,
    EntityColumn,
    Feature,
    Function,
    RollingWindow,
    StreamSource,
    SumFunction,
    TimeseriesColumn,
    TimeWindow,
)
from databricks.bundles.materialization_sets import (
    MaterializationSet,
    MaterializedFeature,
    OnlineStoreConfig,
    StreamingMode,
    StreamingModeStreamingModeType,
)

Dann fügen Sie dies zum Body von load_resources hinzu:

resources.add_feature(
    'events_90m',
    Feature(
        full_name='${var.catalog}.${var.schema}.events_90m',
        description='Events per key over a trailing 90 minutes',
        source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
        function=Function(
            aggregation_function=AggregationFunction(
                count_function=CountFunction(input='value.amount'),
                time_window=TimeWindow(rolling=RollingWindow(window_duration='5400s')),
            )
        ),
        entities=[EntityColumn(name='value.key')],
        timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
    ),
)

resources.add_feature(
    'amount_sum_90m',
    Feature(
        full_name='${var.catalog}.${var.schema}.amount_sum_90m',
        description='Sum of amount per key over a trailing 90 minutes',
        source=DataSource(stream_source=StreamSource(full_name='${var.stream}')),
        function=Function(
            aggregation_function=AggregationFunction(
                sum=SumFunction(input='value.amount'),
                time_window=TimeWindow(rolling=RollingWindow(window_duration='5400s')),
            )
        ),
        entities=[EntityColumn(name='value.key')],
        timeseries_column=TimeseriesColumn(name='value.event_timestamp'),
    ),
)

resources.add_materialization_set(
    'serving_online',
    MaterializationSet(
        materialized_features=[
            MaterializedFeature(
                feature_name='${resources.features.events_90m.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='serving_online',
                ),
                streaming_mode=StreamingMode(
                    mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
                ),
            ),
            MaterializedFeature(
                feature_name='${resources.features.amount_sum_90m.full_name}',
                online_store_config=OnlineStoreConfig(
                    online_store_name='${var.online_store}',
                    catalog_name='${var.catalog}',
                    schema_name='${var.schema}',
                    table_name_prefix='serving_online',
                ),
                streaming_mode=StreamingMode(
                    mode=StreamingModeStreamingModeType.STREAMING_MODE_TYPE_RTM
                ),
            ),
        ]
    ),
)

Eine FeatureSpec hinzufügen

FeatureSpec listet die Funktionen auf, die der Endpoint bedient. Jeder Eintrag in features nennt eine Feature View mit declarative_feature.

A FeatureSpec kann erst erstellt werden, nachdem jede Feature View, die es nennt, in einem Online-Store materialisiert wurde. Die Referenzen ${resources.features...} in declarative_feature lassen die Spezifikation von den Feature Views events_90m und amount_sum_90mabhängen, und lifecycle.depends_on fügt die Abhängigkeit hinzu, die keine Referenz ausdrückt, auf die Materialisierungsmenge serving_online. Das Bundle erstellt die Spezifikation nach allen dreien und löscht sie davor. Siehe Regeln, die ein FeatureSpec erfüllen muss.

YAML

Erstellen Sie resources/feature_spec.yml:

resources:
  feature_specs:
    event_features:
      name: ${var.catalog}.${var.schema}.event_features
      features:
        - declarative_feature:
            feature: ${resources.features.events_90m.full_name}
        - declarative_feature:
            feature: ${resources.features.amount_sum_90m.full_name}
      lifecycle:
        depends_on:
          - resource: materialization_sets.serving_online

Python

Füge die Importe zu resources/__init__.py hinzu:

from databricks.bundles.feature_specs import (
    DeclarativeFeature,
    DependsOn,
    FeatureSpec,
    Features,
    Lifecycle,
)

Dann fügen Sie dies zum Body von load_resources hinzu:

resources.add_feature_spec(
    'event_features',
    FeatureSpec(
        name='${var.catalog}.${var.schema}.event_features',
        features=[
            Features(
                declarative_feature=DeclarativeFeature(
                    feature='${resources.features.events_90m.full_name}'
                )
            ),
            Features(
                declarative_feature=DeclarativeFeature(
                    feature='${resources.features.amount_sum_90m.full_name}'
                )
            ),
        ],
        lifecycle=Lifecycle(depends_on=[DependsOn(resource='materialization_sets.serving_online')]),
    ),
)

Einen Feature Serving Endpunkt hinzufügen

Der Endpunkt bedient das FeatureSpec, das entity_name benennt. Da entity_name auf das name der Spezifikation verweist, erstellt das Bundle den Endpunkt nach der Spezifikation, wie die Ausgabe in Deploy zeigt, und löscht ihn vor der Spezifikation. Mit scale_to_zero_enabled skaliert der Endpunkt seine Rechenleistung auf null, wenn er keine Anfragen erhält.

YAML

Erstellen Sie resources/serving_endpoint.yml:

resources:
  model_serving_endpoints:
    event_endpoint:
      name: ${var.endpoint_name}
      config:
        served_entities:
          - entity_name: ${resources.feature_specs.event_features.name}
            workload_size: Small
            scale_to_zero_enabled: true

Python

Füge die Importe zu resources/__init__.py hinzu:

from databricks.bundles.model_serving_endpoints import (
    EndpointCoreConfigInput,
    ModelServingEndpoint,
    ServedEntityInput,
)

Dann fügen Sie dies zum Body von load_resources hinzu:

resources.add_model_serving_endpoint(
    'event_endpoint',
    ModelServingEndpoint(
        name='${var.endpoint_name}',
        config=EndpointCoreConfigInput(
            served_entities=[
                ServedEntityInput(
                    entity_name='${resources.feature_specs.event_features.name}',
                    workload_size='Small',
                    scale_to_zero_enabled=True,
                )
            ]
        ),
    ),
)

Bereitstellen

Überprüfen Sie die Konfiguration und überprüfen Sie dann, was die Bereitstellung tut:

databricks bundle validate
databricks bundle plan

Bei einer ersten Bereitstellung melden alle fünf Ressourcen create:

create feature_specs.event_features
create features.amount_sum_90m
create features.events_90m
create materialization_sets.serving_online
create model_serving_endpoints.event_endpoint

Plan: 5 to add, 0 to change, 0 to delete, 0 unchanged

Stellen Sie das Bundle in Ihrem Arbeitsbereich bereit:

databricks bundle deploy

Die Bereitstellung erstellt die Ressourcen in Abhängigkeitsreihenfolge und gibt zurück, wenn der Endpunkt bereit ist, was mehrere Minuten dauert:

Uploading bundle files to /Workspace/Users/someone@example.com/.bundle/feature-serving-quickstart/default/files...
Created features.events_90m
Created features.amount_sum_90m
Created materialization_sets.serving_online
Created feature_specs.event_features
Created model_serving_endpoints.event_endpoint
Files: 4 uploaded, 0 deleted
Resources: 5 created, 0 changed, 0 deleted, 0 unchanged

Endpunkt abfragen

Senden Sie die nachzuschlagenden Schlüssel als dataframe_records. Ein Datensatz benennt jeden Schlüssel nach dem letzten Segment des Entitätspfads der Feature View, sodass aus value.keykey wird:

databricks serving-endpoints query event-features --json '{"dataframe_records": [{"key": 1280}, {"key": 1188}, {"key": 42}, {"key": 10001}]}'

Die Antwort enthält für jeden Datensatz ein Objekt in der Reihenfolge der Anfrage. Jedes Objekt enthält einen Wert für jede Feature View, der mit dem Namen der Feature View ohne deren Katalog und Schema als Schlüssel versehen ist:

{
  "outputs": [
    {
      "events_90m": 10,
      "amount_sum_90m": 10
    },
    {
      "events_90m": 11,
      "amount_sum_90m": 11
    },
    {
      "events_90m": 9,
      "amount_sum_90m": 10
    },
    {
      "events_90m": 0,
      "amount_sum_90m": null
    }
  ]
}

Ein Schlüssel ohne Ereignisse im Fenster gibt null für die Zählung und 0 für die Summe zurück, wie es der Schlüssel 10001 tut. Jeder Schlüssel gibt diese Werte zurück, bis die Materialisierungspipeline ihre ersten Zeilen schreibt, was mehrere Minuten nachdem databricks bundle deploy zurückgegeben wurde, der Fall sein kann. Weitere Möglichkeiten, einen Endpunkt abzufragen, finden Sie unter Abfrage eines Endpunkts.

Eine Feature-Ansicht aus dem FeatureSpec entfernen

Jede Änderung an einem FeatureSpec löscht dieses und erstellt es neu. Ein laufender Endpunkt liefert weiterhin die Features in der FeatureSpec, mit der er erstellt wurde, sodass eine Änderung, die den Namen der Spezifikation beibehält, den Endpunkt nicht beeinflusst. Siehe Abhängigkeiten eines Live-Feature Serving-Endpunkts aktualisieren.

Um dies zu sehen, entfernen Sie amount_sum_90m aus dem Spec und behalten Sie seinen Namen:

YAML

   feature_specs:
     event_features:
       name: ${var.catalog}.${var.schema}.event_features
       features:
         - declarative_feature:
             feature: ${resources.features.events_90m.full_name}
-        - declarative_feature:
-            feature: ${resources.features.amount_sum_90m.full_name}
       lifecycle:

Python

         features=[
             Features(
                 declarative_feature=DeclarativeFeature(
                     feature='${resources.features.events_90m.full_name}'
                 )
             ),
-            Features(
-                declarative_feature=DeclarativeFeature(
-                    feature='${resources.features.amount_sum_90m.full_name}'
-                )
-            ),
         ],

databricks bundle plan meldet lediglich, dass die Spezifikation neu erstellt wird:

recreate feature_specs.event_features

Plan: 1 to add, 0 to change, 1 to delete, 4 unchanged

databricks bundle deploy bittet um Bestätigung, bevor es die Spezifikation neu erstellt:

Uploading bundle files to /Workspace/Users/someone@example.com/.bundle/feature-serving-quickstart/default/files...

This action will result in the deletion or recreation of the following feature specs.
Grants on them that are not declared in the bundle are lost:
  recreate resources.feature_specs.event_features

Would you like to proceed? [y/N]: y
Recreated feature_specs.event_features
Files: 1 uploaded, 0 deleted
Resources: 1 created, 0 changed, 1 deleted, 4 unchanged

Der Endpunkt gibt weiterhin beide Features zurück:

databricks serving-endpoints query event-features --json '{"dataframe_records": [{"key": 1188}, {"key": 42}]}'
{
  "outputs": [
    {
      "events_90m": 16,
      "amount_sum_90m": 20
    },
    {
      "events_90m": 12,
      "amount_sum_90m": 11
    }
  ]
}

FeatureSpec umbenennen

Um zu ändern, was der Endpunkt bereitstellt, geben Sie dem FeatureSpec einen neuen Namen. Der Endpunkt entity_name verweist auf den Namen, sodass die Bereitstellung auch den Endpunkt aktualisiert, und der Endpunkt beantwortet weiterhin Anfragen mit den Funktionen des Originals FeatureSpec , bis das Update abgeschlossen ist.

YAML

   feature_specs:
     event_features:
-      name: ${var.catalog}.${var.schema}.event_features
+      name: ${var.catalog}.${var.schema}.event_features_v2

Python

     FeatureSpec(
-        name='${var.catalog}.${var.schema}.event_features',
+        name='${var.catalog}.${var.schema}.event_features_v2',

databricks bundle plan Meldet eine Neuerstellung der Spezifikation und eine Aktualisierung des Endpunkts:

recreate feature_specs.event_features
update model_serving_endpoints.event_endpoint

Plan: 1 to add, 1 to change, 1 to delete, 3 unchanged

databricks bundle deploy fordert eine Bestätigung an, erstellt die Spezifikation neu und wird zurückgegeben, wenn der Endpunkt aktualisiert wurde:

Uploading bundle files to /Workspace/Users/someone@example.com/.bundle/feature-serving-quickstart/default/files...

This action will result in the deletion or recreation of the following feature specs.
Grants on them that are not declared in the bundle are lost:
  recreate resources.feature_specs.event_features

Would you like to proceed? [y/N]: y
Recreated feature_specs.event_features
Updated model_serving_endpoints.event_endpoint
Files: 1 uploaded, 0 deleted
Resources: 1 created, 1 changed, 1 deleted, 3 unchanged

Der Endpunkt gibt jetzt nur noch events_90m:

databricks serving-endpoints query event-features --json '{"dataframe_records": [{"key": 1188}]}'
{
  "outputs": [
    {
      "events_90m": 68
    }
  ]
}

Aufräumen

Die Materialisierungspipeline läuft weiter, und der Endpunkt ist weiterhin erreichbar, bis Sie sie löschen. Baue das Bundle ab, wenn du fertig bist:

databricks bundle destroy

databricks bundle destroy Listet auf, was gelöscht wird, und bittet um Bestätigung:

The following resources will be deleted:
  delete resources.feature_specs.event_features
  delete resources.features.amount_sum_90m
  delete resources.features.events_90m
  delete resources.materialization_sets.serving_online
  delete resources.model_serving_endpoints.event_endpoint

This action will result in the deletion of the following Feature Views.
Deleting a Feature View that a FeatureSpec serves is not blocked, and leaves the FeatureSpec stale:
  delete resources.features.amount_sum_90m
  delete resources.features.events_90m

This action will result in the deletion of the following feature specs.
Feature Serving endpoints and training code that use them can no longer load them:
  delete resources.feature_specs.event_features

All files and directories at the following location will be deleted: /Workspace/Users/someone@example.com/.bundle/feature-serving-quickstart/default

Would you like to proceed? [y/N]: y
Destroy: 5 deleted

Nur der Nutzer, der ein materialisiertes Feature erstellt hat, kann es löschen, also führen Sie databricks bundle destroy mit derselben Identität aus, die das Bundle bereitgestellt hat. Siehe delete_materialized_feature().

Limitations

  • Wenn eine Feature View im Batch-Modus materialisiert wird, existiert ihre Online-Tabelle erst nach dem ersten Lauf des Materialisierungssatzes, sodass ein im selben databricks bundle deploy bereitgestellter Endpunkt fehlschlägt. Führe databricks bundle deploy nach dem ersten Lauf erneut aus.
  • Das Löschen einer Feature-Ansicht, die von einem FeatureSpec bedient wird, ist nicht blockiert und lässt den FeatureSpec veraltet.

Nächste Schritte