Erstellen und verwalten Sie Anbieter mit Model Provider Services

Erfahren Sie, wie Sie einen Anbieter als Modell-Provider-Service registrieren, Zugriff darauf gewähren, Unity Gateway-Funktionen konfigurieren und löschen.

Requirements

  • CREATE SERVICE für das Schema, in dem Sie den Modellanbieter-Dienst erstellen, sowie USE CATALOG und USE SCHEMA für dessen Katalog und Schema.
  • Die Anmeldeinformationen für den externen Anbieter, den Sie registrieren möchten (z. B. einen OpenAI-API-Schlüssel oder ein AWS-Zugriffstastenpaar).
  • Um Azure OpenAI oder Microsoft Foundry mit Anmeldeinformationen für den Dienst statt mit einem Schlüssel oder einem Geheimnis zu authentifizieren, benötigen Sie vorhandene Anmeldeinformationen sowie ACCESS für den Dienst. Weitere Informationen finden Sie unter Authentifizieren von Azure OpenAI oder Microsoft Foundry mit Dienstanmeldeinformationen.

Um eine Provider-Anmeldeinformation mit einem kundeneigenen Unity-Catalog-Geheimnis zu hinterlegen, anstatt den Wert direkt zu speichern, müssen Sie über ein vorhandenes Unity-Catalog-Geheimnis sowie READ SECRET dafür verfügen. Weitere Informationen finden Sie unter „Anmeldeinformationen eines Anbieters mit einem Geheimnis in Unity Catalog absichern“.

Erstellen Sie einen Modell-Provider-Dienst

Modellanbieterdienste und Modelldienste teilen einen namespace mit einem einzigen Namen innerhalb eines Unity-Katalogschemas. Sie können keinen Namen für einen Modellanbieterdienst verwenden, wenn dieser Name im Schema bereits von einem Modelldienst verwendet wird, und umgekehrt.

Erstellen Sie einen Modell-Provider-Service 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).

Benutzeroberfläche

  1. Führen Sie einen der folgenden Schritte aus:
    • In der Seitenleiste des Arbeitsbereichs klicken Sie auf AI Gateway, öffnen Sie dann den Reiter Anbieter und klicken Sie auf Anbieter.
    • Im Katalog-Explorer gehen Sie zu dem Schema, in dem Sie den Modellanbieterdienst erstellen möchten, klicken Sie auf Dienst erstellen>und wählen dann im Dialogfeld Dienst erstellenModellanbieter aus.
  2. Geben Sie einen Namen für den Modellanbieterdienst 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 den Anbietertyp aus, und geben Sie die Verbindungsdetails und Anmeldeinformationen des Anbieters ein.
  4. Klicke auf Erstellen. Azure Databricks verschlüsselt und speichert die Anmeldeinformationen. Die Benutzeroberfläche zeigt sie nach diesem Punkt nicht an.

REST API

Senden Sie eine POST an /api/2.1/unity-catalog/model-provider-services und übergeben Sie parent und model_provider_service_id als Abfrageparameter. Legen Sie provider_type und genau einen passenden Provider-Block fest. targets lässt die erreichbaren Upstream-Modelle zu und Geheimnisse werden inline als Klartext angegeben:

databricks api post \
  "/api/2.1/unity-catalog/model-provider-services?parent=schemas/main.default&model_provider_service_id=my_provider" \
  --json '{
  "comment": "Routes to a custom OpenAI-compatible provider",
  "config": {
    "provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
    "targets": [
      { "model": "gpt-4o", "native_api_types": ["openai/v1/chat/completions"] }
    ],
    "custom": {
      "direct": {
        "base_url": "https://api.example.com/v1",
        "api_key": { "plaintext": "dummy-api-key" }
      }
    }
  }
}'

Befehlszeilenschnittstelle (CLI)

Übergeben Sie das übergeordnete Schema und einen Leaf-Namen und geben Sie die Konfiguration mit --json an. Legen Sie provider_type und genau einen passenden Provider-Block fest; targets führt die erreichbaren Upstream-Modelle auf einer Zulassungsliste, und Geheimnisse werden inline im Klartext bereitgestellt. Um die CLI zu installieren, siehe Installieren oder aktualisieren Sie die Databricks-CLI.

databricks ai-gateway create-model-provider-service schemas/main.default my_provider --json '{
  "comment": "Routes to a custom OpenAI-compatible provider",
  "config": {
    "provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
    "targets": [
      { "model": "gpt-4o", "native_api_types": ["openai/v1/chat/completions"] }
    ],
    "custom": {
      "direct": {
        "base_url": "https://api.example.com/v1",
        "api_key": { "plaintext": "dummy-api-key" }
      }
    }
  }
}'

Terraform

Erstellen und verwalten Sie einen Modell-Provider-Service mit dem Databricks Terraform-Anbieter und der databricks_ai_gateway_model_provider_service-Ressource . Halten Sie reale Schlüssel aus der Quellcodekontrolle heraus, indem Sie den API-Schlüssel durch eine Variable sensitive = true leiten lassen (setzen Sie ihn mit -var oder einer TF_VAR_provider_api_key Umgebungsvariable):

variable "provider_api_key" {
  type      = string
  sensitive = true
}

resource "databricks_ai_gateway_model_provider_service" "example" {
  parent                    = "schemas/main.default"
  model_provider_service_id = "my_provider"
  comment                   = "Routes to a custom OpenAI-compatible provider"

  config = {
    provider_type = "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM"

    targets = [{
      model            = "gpt-4o"
      native_api_types = ["openai/v1/chat/completions"]
    }]

    custom = {
      direct = {
        base_url = "https://api.example.com/v1"
        api_key  = { plaintext = var.provider_api_key }
      }
    }
  }
}

DABs (Beta)

Definieren Sie den Modell-Provider-Service in einem Bundle und bereiten Sie ihn mit databricks bundle deploybereit. Halten Sie reale Schlüssel aus der Quellcode-Kontrolle heraus, indem Sie den API-Schlüssel durch eine Bundle-Variable leiten (setzen Sie ihn mit --var oder einer BUNDLE_VAR_provider_api_key Umweltvariable):

variables:
  provider_api_key:
    description: Provider API key.

resources:
  model_provider_services:
    my_provider:
      parent: schemas/main.default
      model_provider_service_id: my_provider
      comment: Routes to a custom OpenAI-compatible provider
      config:
        provider_type: EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
        targets:
          - model: gpt-4o
            native_api_types: [openai/v1/chat/completions]
        custom:
          direct:
            base_url: https://api.example.com/v1
            api_key:
              plaintext: ${var.provider_api_key}

Python SDK

Erstellen und verwalten Sie einen Modell-Provider-Dienst mit dem Databricks SDK für Python:

from databricks.sdk.service import catalog as c

model_provider_service = w.ai_gateway.create_model_provider_service(
    parent="schemas/main.default",
    model_provider_service_id="my_provider",
    model_provider_service=c.ModelProviderService(
        comment="Routes to a custom OpenAI-compatible provider",
        config=c.ModelProviderServiceConfig(
            provider_type=(
                c.ModelProviderServiceConfigExternalModelProviderType
                .EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
            ),
            targets=[
                c.ModelProviderServiceConfigModelTargetConfig(
                    model="gpt-4o",
                    native_api_types=["openai/v1/chat/completions"],
                )
            ],
            custom=c.ModelProviderServiceConfigCustomProviderConfig(
                direct=c.ModelProviderServiceConfigCustomProviderDirectConfig(
                    base_url="https://api.example.com/v1",
                    api_key=c.ModelProviderServiceConfigProviderSecret(
                        plaintext="dummy-api-key"
                    ),
                )
            ),
        ),
    ),
)

Go Software Development Kit (SDK)

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

modelProviderService, err := w.AiGateway.CreateModelProviderService(ctx,
	catalog.CreateModelProviderServiceRequest{
		Parent:                 "schemas/main.default",
		ModelProviderServiceId: "my_provider",
		ModelProviderService: catalog.ModelProviderService{
			Comment: "Routes to a custom OpenAI-compatible provider",
			Config: &catalog.ModelProviderServiceConfig{
				ProviderType: catalog.ModelProviderServiceConfigExternalModelProviderTypeExternalModelProviderTypeCustom,
				Targets: []catalog.ModelProviderServiceConfigModelTargetConfig{{
					Model:          "gpt-4o",
					NativeApiTypes: []string{"openai/v1/chat/completions"},
				}},
				Custom: &catalog.ModelProviderServiceConfigCustomProviderConfig{
					Direct: &catalog.ModelProviderServiceConfigCustomProviderDirectConfig{
						BaseUrl: "https://api.example.com/v1",
						ApiKey: &catalog.ModelProviderServiceConfigProviderSecret{
							Plaintext: "dummy-api-key",
						},
					},
				},
			},
		},
	})

Go Modular SDK

Erstellen und verwalten Sie einen Modellanbieterdienst 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 }.

modelProviderService, err := c.CreateModelProviderService(ctx,
	aigateway.CreateModelProviderServiceRequest{
		Parent:                 ptr("schemas/main.default"),
		ModelProviderServiceId: ptr("my_provider"),
		ModelProviderService: &aigateway.ModelProviderService{
			Comment: ptr("Routes to a custom OpenAI-compatible provider"),
			Config: &aigateway.ModelProviderServiceConfig{
				ProviderType: aigateway.ModelProviderServiceConfig_ExternalModelProviderType_ExternalModelProviderTypeCustom,
				Targets: []aigateway.ModelProviderServiceConfig_ModelTargetConfig{{
					Model:          ptr("gpt-4o"),
					NativeApiTypes: []string{"openai/v1/chat/completions"},
				}},
				Provider: &aigateway.ModelProviderServiceConfig_Provider_Custom{
					Custom: aigateway.ModelProviderServiceConfig_CustomProviderConfig{
						ProviderMode: &aigateway.ModelProviderServiceConfig_CustomProviderConfig_ProviderMode_Direct{
							Direct: aigateway.ModelProviderServiceConfig_CustomProviderDirectConfig{
								BaseUrl: ptr("https://api.example.com/v1"),
								AuthMode: &aigateway.ModelProviderServiceConfig_CustomProviderDirectConfig_AuthMode_ApiKey{
									ApiKey: aigateway.ModelProviderServiceConfig_ProviderSecret{
										Value: &aigateway.ModelProviderServiceConfig_ProviderSecret_Value_Plaintext{
											Plaintext: "dummy-api-key",
										},
									},
								},
							},
						},
					},
				},
			},
		},
	})

Java SDK

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

ModelProviderServiceConfig config =
    new ModelProviderServiceConfig()
        .setProviderType(
            ModelProviderServiceConfigExternalModelProviderType
                .EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM)
        .setTargets(
            Collections.singletonList(
                new ModelProviderServiceConfigModelTargetConfig()
                    .setModel("gpt-4o")
                    .setNativeApiTypes(
                        Collections.singletonList("openai/v1/chat/completions"))))
        .setCustom(
            new ModelProviderServiceConfigCustomProviderConfig()
                .setDirect(
                    new ModelProviderServiceConfigCustomProviderDirectConfig()
                        .setBaseUrl("https://api.example.com/v1")
                        .setApiKey(
                            new ModelProviderServiceConfigProviderSecret()
                                .setPlaintext("dummy-api-key"))));

ModelProviderService modelProviderService =
    w.aiGateway()
        .createModelProviderService(
            new CreateModelProviderServiceRequest()
                .setParent("schemas/main.default")
                .setModelProviderServiceId("my_provider")
                .setModelProviderService(
                    new ModelProviderService()
                        .setComment("Routes to a custom OpenAI-compatible provider")
                        .setConfig(config)));

JS Modular SDK

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

import { ModelProviderServiceConfig_ExternalModelProviderType as ProviderType } from '@databricks/sdk-aigateway/v1';

const created = await client.createModelProviderService({
  parent: 'schemas/main.default',
  modelProviderServiceId: 'my_provider',
  modelProviderService: {
    comment: 'Routes to a custom OpenAI-compatible provider',
    config: {
      providerType: ProviderType.EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM,
      targets: [{ model: 'gpt-4o', nativeApiTypes: ['openai/v1/chat/completions'] }],
      provider: {
        $case: 'custom',
        custom: {
          providerMode: {
            $case: 'direct',
            direct: {
              baseUrl: 'https://api.example.com/v1',
              authMode: {
                $case: 'apiKey',
                apiKey: {
                  value: { $case: 'plaintext', plaintext: 'dummy-api-key' },
                },
              },
            },
          },
        },
      },
    },
  },
});

Die vollständige Liste der Anbieter und ihrer Authentifizierungsmethoden finden Sie unter Modellanbieter außerhalb von Databricks.

Authentifizieren Sie Azure OpenAI oder Microsoft Foundry mit Dienstanmeldeinformationen

Sie können einen Azure OpenAI- oder Microsoft Foundry-Anbieter mit einer Service-Credential authentifizieren, anstatt einen API-Schlüssel oder ein Microsoft Entra ID Service Principal Client Secret zu speichern. Dienstanmeldeinformationen umfassen eine von Unity Catalog verwaltete Azure-Identität, sodass kein langlebiges Geheimnis in den Dienst des Modellanbieters kopiert wird: Azure Databricks bezieht von dieser Identität kurzlebige Token, um jede Anfrage zu authentifizieren.

Erstellen Sie den Modell-Provider-Service, wie beschrieben in Create a Model Provider Service. Wählen Sie Azure OpenAI oder Microsoft Foundry als Anbietertyp aus und geben Sie dessen Verbindungsdetails ein, einschließlich der Endpunkt-Basis-URL. Dann setze die Auth-Methode auf Service Credential und wähle die Zugangsdaten aus, anstatt einen API-Schlüssel oder ein Client-Geheimnis einzugeben. Eine Service-Zugangsdaten ersetzt nur das Geheimnis, daher ist die Endpunkt-Basis-URL weiterhin erforderlich.

Bestätigen Sie die folgenden Anforderungen:

  • Der Eigentümer des Model-Provider-Dienstes verfügt über ACCESS für die Anmeldeinformationen für den Dienst. Da Azure Databricks den Zugriff des Besitzers beim Ausstellen von Anfragen erneut überprüft, muss der Besitzer ihn so lange behalten, wie der Anbieter genutzt wird. Im Falle eines Widerrufs werden Abfragen für alle angehalten, auch für Aufrufer, die EXECUTE für den Anbieter haben. Um dem Besitzer Zugriff auf die Zugangsberechtigung zu gewähren:

    GRANT ACCESS ON SERVICE CREDENTIAL <service-credential-name> TO `<model-provider-service-owner>`;

  • Der Zweck der Anmeldeinformationen ist der Dienst, nicht die Speicherung.

  • Die Zugangsberechtigung ist in den Arbeitsbereichen verfügbar, aus denen Anfragen kommen. Die Bindungen an den Arbeitsbereich gelten weiterhin, sodass eine Anfrage aus einem Arbeitsbereich, an den die Anmeldeinformationen nicht gebunden sind, dort fehlschlägt, obwohl der Dienst des Modellanbieters selbst von jedem Arbeitsbereich aus erreichbar ist, der denselben Metastore nutzt.

  • Die Azure-Identität der Servicezugangsdaten ist autorisiert, um die von Ihnen geplanten Azure OpenAI- oder Microsoft Foundry-Deployments aufzurufen. Informationen zum Erstellen von Anmeldeinformationen finden Sie unter Anmeldeinformationen erstellen.

Anrufer, die den Anbieter anfragen, benötigen dieselben Zuschüsse wie jeder andere Anbieter. Sie benötigen keine Privilegien für die Dienstberechtigung, was die Berechtigung selbst außerhalb ihrer Reichweite hält.

Der Dienst des Modellanbieters identifiziert einen Zugangsnachweis anhand seiner internen Kennung, sodass Sie ihn umbenennen können, ohne dass Abfragen fehlschlagen.

Wenn Sie eine Zugangsdaten löschen, schlagen Abfragen fehl und es gibt keine Warnung, dass ein Modellanbieter-Dienst darauf verweist. Bestätigen Sie, dass es keine Hinweise auf diese Berechtigung gibt, bevor Sie sie löschen.

Sie können einen bestehenden Modellanbieter-Dienst nicht von der Authentifizierung mit Service-Anmeldedaten auf die Authentifizierung mit API-Schlüssel oder Client-Secret umstellen. Erstelle stattdessen einen neuen Modellanbieter-Dienst.

Senden Sie einen benutzerdefinierten Provider-API-Schlüssel in einem Header

Ein benutzerdefinierter Anbieter sendet standardmäßig seinen API-Schlüssel als Inhabertoken. Wenn Ihr Endpunkt den Schlüssel stattdessen in einem bestimmten Header erwartet, verwenden Sie die API-Schlüssel-Header-Authentifizierung und benennen Sie den Header selbst. Azure Databricks sendet dann den Schlüssel bei jeder ausgehenden Anfrage als .<header name>: <header value>

Erstellen Sie den Modell-Provider-Service, wie beschrieben in Create a Model Provider Service. Wählen Sie als Providertyp Benutzerdefiniert aus, setzen Sie die Authentifizierungsmethode auf API-Schlüssel im Header und geben Sie den von Ihrem Endpunkt erwarteten Headernamen (z. B. X-API-Key oder Ocp-Apim-Subscription-Key) sowie den Headerwert an.

Die beiden Methoden schließen einander aus: Ein benutzerdefinierter Anbieter verwendet entweder ein Bearer-Token oder einen benannten Header, nicht beides. Die Header-Authentifizierung benötigt genau einen Header.

Der Header-Name muss ein gültiger HTTP-Header-Name sein: Buchstaben, Ziffern und die Zeichen !#$%&'*+-.^_`|~, bis zu 255 Zeichen. Jedes andere Zeichen ist unzulässig, einschließlich Leerzeichen, Doppelpunkten, Schrägstrichen und Zeilenumbrüchen.

Sichern Sie eine Provider-Zugangsdaten mit einem Unity-Catalog-Geheimnis

Anstatt die Anmeldedaten eines Anbieters direkt zu speichern, können Sie einen Modellanbieter-Dienst auf ein kundeneigenes Unity Catalog Secret verweisen, das den Wert speichert. Azure Databricks liest das Secret beim Abfragezeitpunkt mit den Zugriffsrechten des Besitzers des Modellanbieterdiensts aus und kopiert den Wert niemals in den Modellanbieterdienst. Daher wird die Rotation des Secrets wirksam, ohne dass Änderungen am Modellanbieterdienst erforderlich sind.

Dies gilt für jeden Anbieter, dessen Zugangsdaten einen einzigen Inline-Wert haben: OpenAI, Azure OpenAI, Anthropic, Amazon Bedrock, Amazon Bedrock Mantle, Microsoft Foundry, Google Gemini Enterprise und Custom.

Erstellen Sie den Modell-Provider-Service, wie beschrieben in Create a Model Provider Service. Wählen Sie den Anbietertyp und geben Sie die Verbindungsdaten ein. Für die Zugangsdaten (wie den API-Schlüssel) ändern Sie den Authentifizierungstyp von Klartext auf Geheim und wählen Sie dann den Katalog, das Schema und das Geheimnis aus, die Ihr Unity-Kataloggeheimnis identifizieren.

Bestätigen Sie die folgenden Anforderungen:

  • Der Besitzer des Modellanbieter-Dienstes hat READ SECRET auf dem Unity-Katalog-Geheimnis. Da Azure Databricks den Zugriff des Besitzers beim Ausstellen von Anfragen erneut überprüft, muss der Besitzer ihn so lange behalten, wie der Anbieter genutzt wird. Im Falle eines Widerrufs werden Abfragen für alle angehalten, auch für Aufrufer, die EXECUTE für den Anbieter haben. Um dem Eigentümer Zugang zum Geheimnis zu gewähren:

    GRANT READ SECRET ON SECRET <catalog>.<schema>.<secret> TO `<model-provider-service-owner>`;

  • Das Unity-Katalog-Geheimnis existiert, bevor du es referenzierst. Um Unity-Kataloggeheimnisse zu erstellen und zu verwalten, siehe Geheimnisse im Unity-Katalog.

Anrufer, die den Anbieter anfragen, benötigen dieselben Zuschüsse wie jeder andere Anbieter. Sie benötigen keine Berechtigung für das Unity Catalog-Geheimnis, wodurch der Wert des Geheimnisses für sie unzugänglich bleibt.

Um die Zugangsdaten zu rotieren, aktualisieren Sie den Wert des Unity-Katalog-Geheimnisses, ohne Änderungen am Modell-Provider-Service.

Wenn du das Unity-Katalog-Geheimnis löschst, schlagen Abfragen fehl. Der Dienst des Modellanbieters behält die nun ungültige Referenz bei, sodass du die Abhängigkeit sehen kannst, und du kannst den Anbieter wiederherstellen, indem du ihn so aktualisierst, dass er auf ein weiterhin vorhandenes Secret verweist.

Das Löschen eines Modell-Provider-Dienstes löscht niemals das Unity-Catalog-Geheimnis, auf das es verweist.

Gewähren Sie Zugang zu einem Modellanbieter-Service

Standardmäßig kann nur der Inhaber des Modellanbieter-Dienstes es abfragen. Damit andere einen Service eines Modellanbieters abfragen können, gewähren Sie ihnen dafür EXECUTE sowie USE CATALOG und USE SCHEMA für den zugehörigen Katalog und das zugehörige Schema. Wenn der Modellanbieterdienst in eine Inferenztabelle protokolliert, gewähren Sie SELECT für die Tabelle, damit er die protokollierten Anfragen und Antworten lesen kann.

Benutzeroberfläche

  1. Öffnen Sie den Modellanbieterdienst 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_provider_service/main.default.my_provider" \
  --json '{
    "changes": [
      { "principal": "data-team", "add": ["EXECUTE"] }
    ]
  }'

Befehlszeilenschnittstelle (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_provider_service main.default.my_provider \
  --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_provider_service = "main.default.my_provider"
  principal              = "data-team"
  privileges             = ["EXECUTE"]
}

DABs (Beta)

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

variables:
  provider_api_key:
    description: Provider API key.

resources:
  model_provider_services:
    my_provider:
      parent: schemas/main.default
      model_provider_service_id: my_provider
      comment: Routes to a custom OpenAI-compatible provider
      config:
        provider_type: EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
        targets:
          - model: gpt-4o
            native_api_types: [openai/v1/chat/completions]
        custom:
          direct:
            base_url: https://api.example.com/v1
            api_key:
              plaintext: ${var.provider_api_key}
      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_provider_service",
    full_name="main.default.my_provider",
    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_provider_service",
	FullName:      "main.default.my_provider",
	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_provider_service")
        .setFullName("main.default.my_provider")
        .setChanges(Arrays.asList(
            new PermissionsChange().setPrincipal("data-team").setAdd(Arrays.asList(Privilege.EXECUTE)))));

Weitere Informationen zum Gewähren und Ermitteln von Zugriff finden Sie unter Externe Modellanbieter (Model-Provider-Dienste) ermitteln und den Zugriff darauf verwalten.

Konfigurieren von Features

Da ein Modellanbieter einen Dienst über Unity Gateway routet, wenden Sie dieselben Governance- und Observabilitätsfunktionen an, die Sie auch für anderen Unity Gateway-Verkehr verwenden:

Konfigurieren Sie einen Preismultiplikator

Standardmäßig schätzt Azure Databricks die Ausgaben des externen Modells anhand der veröffentlichten Listenpreise des Anbieters. Wenn die Preise Ihres Anbieters unterschiedlich sind, konfigurieren Sie einen Preismultiplikator, der Rabatte oder Margen widerspiegelt. Zum Beispiel verwendet 0.8 80 % des Listenpreises, während 1.2 120 % verwendet.

  1. Erstellen Sie einen Modellanbieterdienst oder öffnen Sie einen bestehenden Modellanbieterdienst im Catalog Explorer oder AI Gateway und klicken Sie auf Bearbeiten.
  2. Erweitern Sie Erweiterte Optionen.
  3. Hier kommt ein Preismultiplikator ins Spiel.
  4. Klicken Sie auf Erstellen oder Speichern.

Feld für den Preis-Multiplikator unter „Erweiterte Optionen“ im Dialogfeld „Model Provider Service erstellen“

Der Multiplikator gilt für alle über den Modellanbieter-Service verfügbaren Modelle. Berechnete Ausgaben in system.ai_gateway.external_model_spend spiegeln den konfigurierten Multiplikator wider. Änderungen gelten für Anfragen, die nach Inkrafttreten der Konfiguration gestellt werden; frühere Anfragen werden anhand des Listenpreises oder des zuvor konfigurierten Multiplikators geschätzt.

Ein konfigurierter Multiplikator wird mit dem benutzerdefinierte Preisgestaltung-Tag angezeigt. Bereinigte Preise haben in Preistabellen einen gepunkteten Unterstrich. Fahren Sie mit der Maus über einen angepassten Preis, um den angepassten Preis mit dem Listenpreis des Anbieters zu vergleichen.

Konfigurieren Sie Endpunktrouten für einen benutzerdefinierten Anbieter

Endpoint-Routen sind optional. Nutze sie, wenn ein benutzerdefinierter Anbieter verschiedene Modelle auf unterschiedlichen Pfaden unter demselben base_urlhostet. Ein Modell kann mehrere API-Typen unterstützen. Jedes Modell hat eine Endpunktroute, die von seinen unterstützten API-Typen geteilt wird.

Um eine Route zu konfigurieren, setze endpoint_route beim Ziel auf einen relativen Pfad, nicht auf eine vollständige URL. Unity Gateway fügt die Route am Ende von base_url an, nach jedem Pfad, den base_url bereits enthält.

Benutzeroberfläche

  1. Öffnen Sie den Dialog Modellanbieterdienst erstellen wie in Modellanbieterdienst erstellen beschrieben und wählen Sie im Abschnitt AnbieterBenutzerdefiniert aus.
  2. Im Abschnitt Modelle geben Sie einen Modellnamen ein, wählen die API-Typen aus, die das Modell bedient, und geben Sie einen relativen Pfad in der Endpunkt-Route ein (optional).
  3. Klicken Sie auf Modell hinzufügen. Wiederhole das für jedes Modell.
  4. Klicke auf Erstellen.

REST API

Die folgende Anfrage konfiguriert separate Routen für ein Chat-Modell und ein Embedding-Modell:

databricks api post \
  "/api/2.1/unity-catalog/model-provider-services?parent=schemas/main.default&model_provider_service_id=my_provider" \
  --json '{
  "config": {
    "provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
    "targets": [
      {
        "model": "chat-model",
        "native_api_types": ["openai/v1/chat/completions"],
        "endpoint_route": "serve/openai/chat"
      },
      {
        "model": "embedding-model",
        "native_api_types": ["openai/v1/embeddings"],
        "endpoint_route": "serve/openai/embed"
      }
    ],
    "custom": {
      "direct": {
        "base_url": "https://api.example.com/gateway",
        "api_key": { "plaintext": "placeholder-api-key" }
      }
    }
  }
}'

Damit verwenden Anfragen mit diesem base_url die folgenden Upstream-URLs:

  • chat-model: https://api.example.com/gateway/serve/openai/chat
  • embedding-model: https://api.example.com/gateway/serve/openai/embed

Wenn du endpoint_route weglässt oder es auf einen leeren String setzt, verwendet Unity Gateway base_url unverändert.

native_api_types wählt die API-Übersetzung für jedes Modell aus. Es wählt die Upstream-Route nicht aus und ändert sie nicht.

Aktualisieren Sie einen Modellanbieterdienst

Sie müssen Eigentümer sein oder über MANAGE verfügen. Der Anbietertyp ist unveränderlich.

Benutzeroberfläche

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

REST API

databricks api patch \
  "/api/2.1/unity-catalog/model-provider-services/main.default.my_provider?update_mask=comment" \
  --json '{"comment": "Updated: routes to a custom provider"}'

Befehlszeilenschnittstelle (CLI)

databricks ai-gateway update-model-provider-service model-provider-services/main.default.my_provider comment \
  --json '{"comment": "Updated: routes to a custom provider"}'

Terraform

Bearbeiten Sie databricks_ai_gateway_model_provider_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_provider_service(
    name="model-provider-services/main.default.my_provider",
    update_mask=FieldMask(paths=["comment"]),
    model_provider_service=c.ModelProviderService(
        comment="Updated: routes to a custom provider"
    ),
)

Go Software Development Kit (SDK)

updated, err := w.AiGateway.UpdateModelProviderService(ctx,
	catalog.UpdateModelProviderServiceRequest{
		Name:       "model-provider-services/main.default.my_provider",
		UpdateMask: *fieldmask.New([]string{"comment"}),
		ModelProviderService: catalog.ModelProviderService{
			Comment: "Updated: routes to a custom provider",
		},
	})

Go Modular SDK

mask, err := types.NewFieldMask[aigateway.ModelProviderService]("comment")
updated, err := c.UpdateModelProviderService(ctx,
	aigateway.UpdateModelProviderServiceRequest{
		ModelProviderService: &aigateway.ModelProviderService{
			Name:    ptr("model-provider-services/main.default.my_provider"),
			Comment: ptr("Updated: routes to a custom provider"),
		},
		UpdateMask: mask,
	})

Java SDK

ModelProviderService updated =
    w.aiGateway()
        .updateModelProviderService(
            new UpdateModelProviderServiceRequest()
                .setName("model-provider-services/main.default.my_provider")
                .setUpdateMask(FieldMask.newBuilder().addPaths("comment").build())
                .setModelProviderService(
                    new ModelProviderService()
                        .setComment("Updated: routes to a custom provider")));

JS Modular SDK

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

const updated = await client.updateModelProviderService({
  modelProviderService: {
    name: 'model-provider-services/main.default.my_provider',
    comment: 'Updated: routes to a custom provider',
  },
  updateMask: modelProviderServiceFieldMask('comment'),
});

Löschen eines Modellanbieterdiensts

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

Benutzeroberfläche

Öffnen Sie den Modell-Provider-Service 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-provider-services/main.default.my_provider"

Befehlszeilenschnittstelle (CLI)

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

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_provider_service(
    name="model-provider-services/main.default.my_provider"
)

Go Software Development Kit (SDK)

err := w.AiGateway.DeleteModelProviderService(ctx,
	catalog.DeleteModelProviderServiceRequest{
		Name: "model-provider-services/main.default.my_provider",
	})

Go Modular SDK

err := c.DeleteModelProviderService(ctx,
	aigateway.DeleteModelProviderServiceRequest{
		Name: ptr("model-provider-services/main.default.my_provider"),
	})

Java SDK

w.aiGateway()
    .deleteModelProviderService(
        new DeleteModelProviderServiceRequest()
            .setName("model-provider-services/main.default.my_provider"));

JS Modular SDK

await client.deleteModelProviderService({
  name: 'model-provider-services/main.default.my_provider',
});

Nächste Schritte

  • Zuletzt aktualisiert um