Dienste für benutzerdefinierte Modelle

Ein Modelldienst ist ein Endpunkt, der Inferenzanfragen für ein oder mehrere Modelle verarbeitet und weiterleitet, mit Verkehrsaufteilung und Fallbacks. Es unterstützt Echtzeit-Anfragen sowie Batch-Inferenz.

Erstellen Sie einen benutzerdefinierten Modelldienst für Anwendungsfälle wie:

  • Ein modellunabhängiger Endpunkt für eine Anwendung. Bieten Sie einem Kundensupport-Assistenten einen Service namens production.ai.support-assistant. Ändern Sie das zugrunde liegende Modell, ohne den Namen zu ändern, den die Anwendung verwendet.
  • Benutzerdefiniertes Routing und Rückfallpläne. Verwenden Sie Verkehrsaufteilung , um 10% Verkehr an ein neues Modell zu senden, bevor ein breiterer Rollout erfolgt, oder konfigurieren Sie ein Backup-Ziel für fehlgeschlagene Anfragen.
  • Ein Budget für eine Arbeitslast. Kennzeichnen Sie einen Dienst mit project=support-assistant und ordnen Sie dieser Kennzeichnung ein monatliches Budget zu, mit einer Warnung bei Ausgaben von 1.000 $.
  • Zugangskontrollen für ein Team. Gewähren Sie dem Rechtsteam und seinen Anwendungsdienstleitern Zugang zu einem legal-review Dienst und nutzen Sie separate Dienste für andere Teams.
  • Ratenbegrenzungen für eine Arbeitsbelastung. Konfigurieren Sie einen Testdienst für 100 Anfragen pro Minute und einen Produktionsdienst für 1.000 Anfragen pro Minute unter Verwendung von Service-Rate-Grenzen.
  • Getrennte Überwachung und Protokolle. Senden Sie die Anfragen und Antworten eines Support-Assistenten an eine dedizierte Inferenztabelle , damit dessen Verkehr getrennt vom Verkehr des Coding-Agenten überprüft werden kann.

Um ein von Azure Databricks bedientes Foundation-Modell abzufragen, ohne einen Dienst zu erstellen, verwenden Sie einen systembereitgestellten Modelldienst in system.ai.

Ein Dienst kann zu Azure Databricks-Served-Modellen routen, indem er Pay-per-Token oder provisioned Throughput verwendet, oder über einen Modellanbieter zu externen Modellen. Du kannst diese Ziele in einem Dienst kombinieren.

Benutzerdefinierte Modelldienste sind sicherungsfähige Objekte im Unity Catalog. Aufrufer rufen sie mit ihrem vollständig qualifizierten Namen, catalog.schema.name, arbeitsbereichsübergreifend oder von außerhalb von Azure Databricks auf. Siehe Verwaltung und Privilegien.

Requirements

Hinweis

Unity Gateway wird auf Azure Government nicht unterstützt.

  • Ein Azure Databricks Workspace in einer von Unity Gateway unterstützten Region.
  • Unity-Katalog für Ihren Arbeitsbereich aktiviert. Weitere Informationen finden Sie unter Aktivieren eines Arbeitsbereichs für Unity Catalog.
  • Zum Erstellen eines Modelldiensts benötigen Sie Folgendes:
    • USE CATALOG, USE SCHEMAund CREATE SERVICE im Katalog und Schema, in dem Sie den Modelldienst erstellen.
    • EXECUTE auf jedem Modell, auf das der Modelldienst als Ziel verweist.
    • EXECUTE, USE CATALOG und USE SCHEMA für jeden Modellanbieter, den der Modellservice als Ziel referenziert.
    • USE CATALOG, USE SCHEMA und CREATE TABLE für den Katalog und das Schema, in denen die Inferenztabelle erstellt wird, wenn Sie die Inferenzprotokollierung aktivieren.

Erstellen Sie einen benutzerdefinierten Modellservice

Erstellen Sie einen Modelldienst in der Unity Gateway UI oder im Catalog Explorer. Um eines programmatisch zu erstellen, verwenden Sie die REST API, die Azure Databricks SDKs, die Azure Databricks CLI, Terraform oder Declarative Automation Bundles (DABs).

Modelldienste und Modellanbieter teilen sich einen einzigen Namensraum innerhalb eines Unity-Katalog-Schemas. Man kann keinen Namen für einen Modelldienst verwenden, wenn ein Modellanbieter im Schema ihn bereits verwendet, und umgekehrt.

Benutzeroberfläche

  1. Führen Sie einen der folgenden Schritte aus:
    • Klicken Sie in der Arbeitsbereichs-Randleiste auf "AI-Gateway", und klicken Sie dann auf "Erstellen".
    • Wechseln Sie im Katalog-Explorer zu dem Schema, in dem Sie den Modelldienst erstellen möchten, und klicken Sie dann auf Erstellen>Dienst>Modelldienst.
  2. Geben Sie einen Namen für den Modelldienst ein, und wählen Sie den Katalog und das Schema aus, in dem er erstellt werden soll. Wenn Sie mit dem Katalog-Explorer beginnen, füllt der Katalog-Explorer den Katalog und das Schema vor.
  3. Wählen Sie das Hauptziel aus, das Sie bedienen möchten. Dieses Ziel kann ein von Azure Databricks bereitgestelltes Modell sein, für das Sie EXECUTE haben und das von Unity Gateway bereitgestellt werden kann, oder ein Modellanbieter, für den Sie USE CATALOG, USE SCHEMA und EXECUTE haben.
  4. Klicke auf Erstellen.

Nachdem Sie den Modelldienst erstellt haben, öffnet Azure Databricks die Übersichtsseite, auf der Sie beginnen oder zusätzliche Features wie die Ableitungsprotokollierung konfigurieren können.

REST API

Senden Sie ein POST an /api/2.1/unity-catalog/model-services, wobei parent und model_service_id als Abfrageparameter übergeben werden. Die Routing-Konfiguration muss mindestens ein Ziel haben:

databricks api post \
  "/api/2.1/unity-catalog/model-services?parent=schemas/main.default&model_service_id=my_model_service" \
  --json '{
  "comment": "Routes chat traffic to a foundation model",
  "config": {
    "routing": {
      "destinations": [
        {
          "name": "primary",
          "destination_type": "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL",
          "pay_per_token_config": { "model": "models/system.ai.databricks-gpt-5" },
          "traffic_percentage": 100
        }
      ]
    }
  }
}'

CLI

Übergeben Sie das übergeordnete Schema und einen Leaf-Namen und geben Sie die Konfiguration mit --json an. Die Routing-Konfiguration muss mindestens ein Ziel haben. Um die CLI zu installieren, siehe Installieren oder aktualisieren Sie die Databricks-CLI.

databricks ai-gateway create-model-service schemas/main.default my_model_service --json '{
  "comment": "Routes chat traffic to a foundation model",
  "config": {
    "routing": {
      "destinations": [
        {
          "name": "primary",
          "destination_type": "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL",
          "pay_per_token_config": { "model": "models/system.ai.databricks-gpt-5" },
          "traffic_percentage": 100
        }
      ]
    }
  }
}'

Terraform

Erstellen und verwalten Sie einen Modelldienst mit dem Databricks Terraform-Anbieter und der databricks_ai_gateway_model_service-Ressource :

resource "databricks_ai_gateway_model_service" "example" {
  parent           = "schemas/main.default"
  model_service_id = "my_model_service"
  comment          = "Routes chat traffic to a foundation model"

  config = {
    routing = {
      destinations = [{
        name                 = "primary"
        destination_type     = "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL"
        pay_per_token_config = { model = "models/system.ai.databricks-gpt-5" }
        traffic_percentage   = 100
      }]
    }
  }
}

DABs (Beta)

Definiere den Modelldienst in einem Bundle und bereite ihn mit databricks bundle deployaus. Die Routing-Konfiguration muss mindestens ein Ziel haben:

resources:
  model_services:
    my_model_service:
      parent: schemas/main.default
      model_service_id: my_model_service
      comment: Routes chat traffic to a foundation model
      config:
        routing:
          destinations:
            - name: primary
              destination_type: DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
              pay_per_token_config:
                model: models/system.ai.databricks-gpt-5
              traffic_percentage: 100

Python SDK

Erstellen und verwalten Sie einen Modelldienst mit dem Databricks SDK für Python:

from databricks.sdk.service import catalog as c

model_service = w.ai_gateway.create_model_service(
    parent="schemas/main.default",
    model_service_id="my_model_service",
    model_service=c.ModelService(
        comment="Routes chat traffic to a foundation model",
        config=c.ModelServiceConfig(
            routing=c.ModelServiceConfigRoutingConfig(
                destinations=[
                    c.ModelServiceConfigDestinationConfig(
                        name="primary",
                        destination_type=(
                            c.ModelServiceConfigDestinationConfigDestinationType
                            .DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
                        ),
                        pay_per_token_config=c.ModelServiceConfigPayPerTokenConfig(
                            model="models/system.ai.databricks-gpt-5"
                        ),
                        traffic_percentage=100,
                    )
                ]
            )
        ),
    ),
)

Go Software Development Kit (SDK)

Erstellen und verwalten Sie einen Modellservice mit dem Databricks SDK für Go:

modelService, err := w.AiGateway.CreateModelService(ctx, catalog.CreateModelServiceRequest{
	Parent:         "schemas/main.default",
	ModelServiceId: "my_model_service",
	ModelService: catalog.ModelService{
		Comment: "Routes chat traffic to a foundation model",
		Config: &catalog.ModelServiceConfig{
			Routing: &catalog.ModelServiceConfigRoutingConfig{
				Destinations: []catalog.ModelServiceConfigDestinationConfig{{
					Name:            "primary",
					DestinationType: catalog.ModelServiceConfigDestinationConfigDestinationTypeDestinationTypePayPerTokenFoundationModel,
					PayPerTokenConfig: &catalog.ModelServiceConfigPayPerTokenConfig{
						Model: "models/system.ai.databricks-gpt-5",
					},
					TrafficPercentage: 100,
				}},
			},
		},
	},
})

Go Modular SDK

Erstellen und verwalten Sie einen Modelldienst mit dem Databricks AI Gateway SDK für Go. Optionale Felder sind Zeiger, daher verwendet das Beispiel einen einzeiligen Helfer, func ptr[T any](v T) *T { return &v }.

modelService, err := c.CreateModelService(ctx, aigateway.CreateModelServiceRequest{
	Parent:         ptr("schemas/main.default"),
	ModelServiceId: ptr("my_model_service"),
	ModelService: &aigateway.ModelService{
		Comment: ptr("Routes chat traffic to a foundation model"),
		Config: &aigateway.ModelServiceConfig{
			Routing: &aigateway.ModelServiceConfig_RoutingConfig{
				Destinations: []aigateway.ModelServiceConfig_DestinationConfig{{
					Name:              ptr("primary"),
					DestinationType:   aigateway.ModelServiceConfig_DestinationConfig_DestinationType_DestinationTypePayPerTokenFoundationModel,
					TrafficPercentage: ptr(100),
					TypeConfig: &aigateway.ModelServiceConfig_DestinationConfig_TypeConfig_PayPerTokenConfig{
						PayPerTokenConfig: aigateway.ModelServiceConfig_PayPerTokenConfig{
							Model: ptr("models/system.ai.databricks-gpt-5"),
						},
					},
				}},
			},
		},
	},
})

Java SDK

Erstellen und verwalten Sie einen Modelldienst mit dem Databricks SDK für Java:

ModelServiceConfig config =
    new ModelServiceConfig()
        .setRouting(
            new ModelServiceConfigRoutingConfig()
                .setDestinations(
                    Collections.singletonList(
                        new ModelServiceConfigDestinationConfig()
                            .setName("primary")
                            .setDestinationType(
                                ModelServiceConfigDestinationConfigDestinationType
                                    .DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL)
                            .setPayPerTokenConfig(
                                new ModelServiceConfigPayPerTokenConfig()
                                    .setModel("models/system.ai.databricks-gpt-5"))
                            .setTrafficPercentage(100L))));

ModelService modelService =
    w.aiGateway()
        .createModelService(
            new CreateModelServiceRequest()
                .setParent("schemas/main.default")
                .setModelServiceId("my_model_service")
                .setModelService(
                    new ModelService()
                        .setComment("Routes chat traffic to a foundation model")
                        .setConfig(config)));

JS Modular SDK

Erstellen und verwalten Sie einen Modelldienst mit dem Databricks AI Gateway SDK für JavaScript:

import { ModelServiceConfig_DestinationConfig_DestinationType as DestType } from '@databricks/sdk-aigateway/v1';

const created = await client.createModelService({
  parent: 'schemas/main.default',
  modelServiceId: 'my_model_service',
  modelService: {
    comment: 'Routes chat traffic to a foundation model',
    config: {
      routing: {
        destinations: [
          {
            name: 'primary',
            destinationType: DestType.DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL,
            typeConfig: {
              $case: 'payPerTokenConfig',
              payPerTokenConfig: { model: 'models/system.ai.databricks-gpt-5' },
            },
            trafficPercentage: 100,
          },
        ],
      },
    },
  },
});

Zugang zu einem Modelldienst gewähren

Standardmäßig kann nur der Inhaber des Modelldienstes diese Abfrage durchführen. Damit andere einen Modellservice abfragen können, gewähren Sie ihnen EXECUTE für ihn sowie USE CATALOG und USE SCHEMA für seinen Katalog und sein Schema. Wenn der Modelldienst in eine Inferenztabelle protokolliert, gewähren Sie SELECT-Berechtigungen für die Tabelle, damit die protokollierten Anfragen und Antworten gelesen werden können.

Benutzeroberfläche

  1. Öffnen Sie den Modelldienst im Katalogexplorer oder gehen Sie zu AI Gateway und wählen Sie den Dienst aus.
  2. Wechseln Sie zur Registerkarte Berechtigungen.
  3. Klicken Sie auf Erlauben.
  4. Wählen Sie die Benutzer, Gruppen oder Dienstprinzipale aus, um Zugriff zu gewähren.
  5. Wählen Sie die EXECUTE-Berechtigung aus .
  6. Klicken Sie auf Erlauben.

REST API

databricks api patch \
  "/api/2.1/unity-catalog/permissions/model_service/main.default.my_model_service" \
  --json '{
    "changes": [
      { "principal": "data-team", "add": ["EXECUTE"] }
    ]
  }'

CLI

Weisen Sie EXECUTE mit der Databricks-CLI zu. Um die CLI zu installieren, siehe Installieren oder aktualisieren Sie die Databricks-CLI.

databricks grants update model_service main.default.my_model_service \
  --json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'

Terraform

Grant EXECUTE mit dem Databricks Terraform-Anbieter und der databricks_grant Ressource:

resource "databricks_grant" "example" {
  model_service = "main.default.my_model_service"
  principal     = "data-team"
  privileges    = ["EXECUTE"]
}

DABs (Beta)

Füge einen Block grants zur Modellservice-Ressource in deinem Bundle hinzu und deploye neu, um Zugriff zu gewähren.

resources:
  model_services:
    my_model_service:
      parent: schemas/main.default
      model_service_id: my_model_service
      comment: Routes chat traffic to a foundation model
      config:
        routing:
          destinations:
            - name: primary
              destination_type: DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
              pay_per_token_config:
                model: models/system.ai.databricks-gpt-5
              traffic_percentage: 100
      grants:
        - principal: data-team
          privileges: [EXECUTE]

Python SDK

Grant EXECUTE mit dem Databricks SDK für Python:

from databricks.sdk.service import catalog as c

w.grants.update(
    securable_type="model_service",
    full_name="main.default.my_model_service",
    changes=[c.PermissionsChange(principal="data-team", add=[c.Privilege.EXECUTE])],
)

Go Software Development Kit (SDK)

Weisen Sie EXECUTE mit dem Databricks SDK für Go zu:

_, err := w.Grants.Update(ctx, catalog.UpdatePermissions{
	SecurableType: "model_service",
	FullName:      "main.default.my_model_service",
	Changes: []catalog.PermissionsChange{{
		Principal: "data-team",
		Add:       []catalog.Privilege{catalog.PrivilegeExecute},
	}},
})

Java SDK

Weisen Sie EXECUTE mit dem Databricks SDK für Java zu:

w.grants().update(
    new UpdatePermissions()
        .setSecurableType("model_service")
        .setFullName("main.default.my_model_service")
        .setChanges(Arrays.asList(
            new PermissionsChange().setPrincipal("data-team").setAdd(Arrays.asList(Privilege.EXECUTE)))));

Weitere Informationen zum Gewähren und Ermitteln von Zugriff auf Modelldienste finden Sie unter Ermitteln und Verwalten des Zugriffs auf Modelldienste.

Funktionen auf einem Modelldienst konfigurieren

Konfigurieren Sie Ratenbegrenzungen, Inferenzprotokollierung und Schutzmechanismen, die mithilfe von Service-Richtlinien für den Modelldienst implementiert sind, über die Unity-Gateway-Benutzeroberfläche. See:

Inferenzprotokollierung

Wenn Sie die Ableitungsprotokollierung aktivieren, erstellt Azure Databricks eine neue, leere Unity-Katalogtabelle mit einem vordefinierten Schema an dem von Ihnen angegebenen Speicherort. Beachten Sie Folgendes:

  • Sie müssen über USE CATALOG, USE SCHEMA und CREATE TABLE für den Zielkatalog und das Zielschema verfügen.
  • Der Ersteller des Modelldiensts ist der Besitzer der Rückschlusstabelle. Keine anderen Benutzer haben Zugriff, es sei denn, Sie gewähren sie.
  • Wenn an dem angegebenen Speicherort bereits eine Tabelle vorhanden ist, schlägt das Erstellen des Modelldiensts fehl.
  • Die Ableitungstabelle verfügt über einen unabhängigen Lebenszyklus vom Modelldienst. Wenn Sie die Tabelle ablegen, funktioniert der Modelldienst weiterhin, aber die Protokollierung wird beendet.

Weitere Informationen zu Inferenztabellen finden Sie unter Log-Anfragen und Antworten auf Inferenztabellen.

Aktualisierung eines Modelldienstes

Sie müssen Eigentümer sein oder über MANAGE verfügen.

Benutzeroberfläche

Bearbeiten Sie die Konfiguration des Modelldienstes über die Unity Gateway UI oder den Catalog Explorer. Änderungen werden direkt übernommen.

REST API

databricks api patch \
  "/api/2.1/unity-catalog/model-services/main.default.my_model_service?update_mask=comment" \
  --json '{"comment": "Updated: routes chat traffic"}'

CLI

databricks ai-gateway update-model-service model-services/main.default.my_model_service comment \
  --json '{"comment": "Updated: routes chat traffic"}'

Terraform

Bearbeiten Sie databricks_ai_gateway_model_service (oder jedes andere änderbare Feld) in der Ressource comment und wenden Sie sie erneut an. Änderungen werden direkt übernommen.

DABs (Beta)

Bearbeite comment (oder ein anderes veränderbares Feld) in der Bundle-Ressource und führe databricks bundle deploy. Änderungen werden direkt übernommen.

Python SDK

from databricks.sdk.service import catalog as c
from google.protobuf.field_mask_pb2 import FieldMask

updated = w.ai_gateway.update_model_service(
    name="model-services/main.default.my_model_service",
    update_mask=FieldMask(paths=["comment"]),
    model_service=c.ModelService(comment="Updated: routes chat traffic"),
)

Go Software Development Kit (SDK)

updated, err := w.AiGateway.UpdateModelService(ctx, catalog.UpdateModelServiceRequest{
	Name:         "model-services/main.default.my_model_service",
	UpdateMask:   *fieldmask.New([]string{"comment"}),
	ModelService: catalog.ModelService{Comment: "Updated: routes chat traffic"},
})

Go Modular SDK

mask, err := types.NewFieldMask[aigateway.ModelService]("comment")
updated, err := c.UpdateModelService(ctx, aigateway.UpdateModelServiceRequest{
	ModelService: &aigateway.ModelService{
		Name:    ptr("model-services/main.default.my_model_service"),
		Comment: ptr("Updated: routes chat traffic"),
	},
	UpdateMask: mask,
})

Java SDK

ModelService updated =
    w.aiGateway()
        .updateModelService(
            new UpdateModelServiceRequest()
                .setName("model-services/main.default.my_model_service")
                .setUpdateMask(FieldMask.newBuilder().addPaths("comment").build())
                .setModelService(
                    new ModelService().setComment("Updated: routes chat traffic")));

JS Modular SDK

import { modelServiceFieldMask } from '@databricks/sdk-aigateway/v1';

const updated = await client.updateModelService({
  modelService: {
    name: 'model-services/main.default.my_model_service',
    comment: 'Updated: routes chat traffic',
  },
  updateMask: modelServiceFieldMask('comment'),
});

Löschen eines Modelldienstes

Sie müssen Eigentümer sein oder über MANAGE verfügen. Die in system.ai vom System bereitgestellten Modelldienste können nicht gelöscht werden.

Benutzeroberfläche

Öffnen Sie den Modelldienst in der Unity Gateway UI oder im Catalog Explorer und wählen Sie im Kebab-Menü Löschen.

REST API

databricks api delete "/api/2.1/unity-catalog/model-services/main.default.my_model_service"

CLI

databricks ai-gateway delete-model-service model-services/main.default.my_model_service

Terraform

Führe terraform destroy aus, oder entferne den Ressourcenblock und wende ihn erneut an.

DABs (Beta)

Entferne die Ressource aus dem Bundle und führe databricks bundle deploy aus, um sie zu löschen. databricks bundle destroy Funktioniert auch, aber es entfernt jede Ressource, die das Bundle verwaltet, nicht nur diese hier.

Python SDK

w.ai_gateway.delete_model_service(name="model-services/main.default.my_model_service")

Go Software Development Kit (SDK)

err := w.AiGateway.DeleteModelService(ctx, catalog.DeleteModelServiceRequest{
	Name: "model-services/main.default.my_model_service",
})

Go Modular SDK

err := c.DeleteModelService(ctx, aigateway.DeleteModelServiceRequest{
	Name: ptr("model-services/main.default.my_model_service"),
})

Java SDK

w.aiGateway()
    .deleteModelService(
        new DeleteModelServiceRequest().setName("model-services/main.default.my_model_service"));

JS Modular SDK

await client.deleteModelService({ name: 'model-services/main.default.my_model_service' });

Verwaltung und Privilegien

Als Sicherungsobjekt in Unity Catalog ist ein Modellservice:

  • Lebt in einem Katalog und Schema, wo es Schemaeinstellungen wie Arbeitsbereichsbindungen erbt.
  • Enthält Standardmetadaten des Unity-Katalogs, z. B. Name, Besitzer, Kommentar und Tags.
  • Unterliegt den Unity-Katalogrechten, sodass Sie den Zugriff mit denselben GRANT Anweisungen REVOKE gewähren, die Sie für Tabellen, Funktionen und Modelle verwenden.
  • Ist im Katalog-Explorer zusammen mit den restlichen Unity-Katalogressourcen auffindbar.

Die folgenden Berechtigungen gelten:

Privileg Beschreibung
USE CATALOG, USE SCHEMA Greifen Sie auf den Katalog und das Schema zu, der den Modelldienst enthält. Erforderlich für alle Vorgänge.
CREATE SERVICE Erstellen sie Modelldienste in einem Schema. Wird für den Katalog oder das Schema gewährt.
EXECUTE Einen Modelldienst abfragen.
MANAGE Ändern oder Löschen eines Modelldiensts und Verwalten seiner Zuschüsse. Der Besitzer hat eine Obermenge von MANAGE.

Modelldienste nutzen die Privilegien des Definierers. Azure Databricks bewertet eine Abfrage anhand der Rechte des Besitzers und nicht der des Anrufers. Wenn ein Benutzer einen Modellservice abfragt, überprüft Azure Databricks, ob der Besitzer über EXECUTE für die referenzierten Ziele verfügt, beispielsweise die zugrunde liegenden Modelle und alle Modellanbieter. Der Anrufer benötigt keinen direkten Zugang zu diesen Zielen.

Limitations

Die folgenden Funktionen werden nicht unterstützt:

  • Erstellung und Verwaltung von Modelldiensten mit SQL.
  • Ermitteln von Modelldiensten mit ausschließlich BROWSE-Berechtigungen.
  • Globale Suche nach Modelldienstleistungen.

Zusätzliche Ressourcen

  • Zuletzt aktualisiert um