Creare e gestire fornitori con i Servizi Fornitori Modello

Impara a registrare un provider come servizio modello di fornitore, concedergli l'accesso, configurare le funzionalità del Gateway Unity e eliminarlo.

Requisiti

  • CREATE SERVICE nello schema in cui si crea il servizio del provider di modelli, oltre a USE CATALOG e USE SCHEMA per il catalogo e lo schema corrispondenti.
  • Le credenziali per il provider esterno da registrare, ad esempio una chiave API OpenAI o una coppia di chiavi di accesso AWS.
  • Per autenticare Azure OpenAI o Microsoft Foundry con una credenziale di servizio invece di una chiave o un segreto, devi avere una credenziale di servizio esistente e ACCESS su di essa. Vedi Autentica Azure OpenAI o Microsoft Foundry con una credenziale di servizio.

Per proteggere una credenziale del provider con un segreto di Unity Catalog di proprietà del cliente, invece di memorizzare direttamente il valore, devi disporre di un segreto di Unity Catalog esistente e di READ SECRET su di esso. Vedi una credenziale di fornitore con un segreto del catalogo Unity.

Crea un servizio modello di fornitore

I servizi del provider di modelli e i servizi del modello condividono un unico spazio dei nomi all'interno di uno schema di Unity Catalog. Non è possibile usare un nome per un servizio provider di modelli se un servizio modello nello schema lo usa già e viceversa.

Crea un servizio di fornitore modello nell'interfaccia utente Unity Gateway o nell'esploratore catalogo. Per crearne uno programmaticamente, usa l'API REST, gli Azure Databricks SDK, la CLI di Azure Databricks, Terraform o i Declarative Automation Bundles (DAB).

Interfaccia utente

  1. Eseguire una delle operazioni seguenti:
    • Nella barra laterale dello spazio di lavoro, clicca su AI Gateway, poi apri la scheda Fornitori e clicca su Fornitore.
    • In Esploratore catalogo, vai allo schema dove vuoi creare il servizio provider modello, clicca Crea>servizio, poi seleziona Servizio fornitore modello nella finestra di dialogo Crea un servizio .
  2. Immettere un nome per il servizio provider di modelli e selezionare il catalogo e lo schema in cui crearlo. Se si inizia da Esplora cataloghi, Esplora cataloghi precompila il catalogo e lo schema.
  3. Selezionare il tipo di provider e immettere i dettagli e le credenziali di connessione del provider.
  4. Clicca su Crea. Azure Databricks crittografa e archivia le credenziali. L'interfaccia utente non li visualizza dopo questo punto.

REST API

Invia POST a /api/2.1/unity-catalog/model-provider-services, passando parent e model_provider_service_id come parametri di query. Imposta provider_type ed esattamente un blocco del provider corrispondente; targets definisce l'elenco consentito dei modelli upstream raggiungibili e i segreti sono forniti in linea in testo semplice:

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" }
      }
    }
  }
}'

CLI

Passa lo schema padre e un nome della foglia, e fornisci la configurazione con --json. Imposta provider_type e esattamente un blocco provider corrispondente; targets permette di elencare i modelli a monte raggiungibili, e i segreti sono forniti in linea come testo in chiaro. Per installare la CLI, vedi Installa o aggiorna la CLI Databricks.

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

Crea e gestisci un servizio di fornitore modello con il fornitore Databricks Terraform e la risorsa databricks_ai_gateway_model_provider_service . Tieni le chiavi reali fuori dal controllo del codice sorgente passando la chiave API tramite una variabile sensitive = true (impostala con -var o con una variabile di ambiente TF_VAR_provider_api_key):

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 }
      }
    }
  }
}

DAB (Beta)

Definisci il servizio provider modello in un bundle e distribuiscilo con databricks bundle deploy. Mantieni le chiavi reali fuori dal controllo del codice sorgente passando la chiave API tramite una variabile del bundle (impostala con --var o una variabile di ambiente BUNDLE_VAR_provider_api_key):

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

Crea e gestisci un servizio di fornitore di modelli con l'SDK Databricks per 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"
                    ),
                )
            ),
        ),
    ),
)

SDK di sviluppo Go

Crea e gestisci un servizio di fornitore modello con l'SDK Databricks per 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

Crea e gestisci un servizio provider di modelli con lo SDK Databricks AI Gateway per Go. I campi opzionali sono puntatori, quindi l'esempio utilizza una funzione di supporto su una sola riga, 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

Crea e gestisci un servizio di fornitore di modelli con l'SDK Databricks per 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)));

SDK modulare JS

Crea e gestisci un servizio di fornitore modello con l'SDK Databricks AI Gateway per 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' },
                },
              },
            },
          },
        },
      },
    },
  },
});

Per l'elenco completo dei provider e dei loro metodi di autenticazione, vedi Fornitori modello esterni a Databricks.

Autentica Azure OpenAI o Microsoft Foundry con una credenziale di servizio

Puoi autenticare un provider Azure OpenAI o Microsoft Foundry con una credenziale di servizio invece di memorizzare una chiave API o il segreto client del service principal di Microsoft Entra ID. Una credenziale di servizio detiene un'identità Azure che Unity Catalog governa, quindi nessun segreto di lunga durata viene copiato nel servizio fornitore modello: Azure Databricks ottiene token di breve durata da quell'identità per autenticare ogni richiesta.

Crea il servizio fornitore modello come descritto in Crea un servizio fornitore modello. Seleziona Azure OpenAI o Microsoft Foundry come tipo di provider e inserisci i dettagli della connessione, incluso l'URL base dell'endpoint. Poi imposta il metodo Auth su Service credential e seleziona la credenziale invece di inserire una chiave API o un client secret. Una credenziale di servizio sostituisce solo il segreto, quindi l'URL base dell'endpoint è comunque necessario.

Verificare i requisiti seguenti:

  • Il proprietario del servizio fornitore modello ha ACCESS sulla credenziale del servizio. Poiché Azure Databricks ricontrolla l'accesso del proprietario quando gestisce le richieste, il proprietario deve conservarlo finché il provider è in uso. La revoca interrompe le query per tutti, anche per i chiamanti che mantengono un EXECUTE sul provider. Per concedere al proprietario l'accesso alla credenziale:

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

  • Lo scopo della credenziale è il servizio, non lo stoccaggio.

  • La credenziale è disponibile negli spazi di lavoro da cui provengono le richieste. I suoi binding di spazio di lavoro si applicano ancora, quindi una richiesta da parte di uno spazio di lavoro a cui la credenziale non è destinata fallisce lì, anche se il servizio di fornitore modello è raggiungibile da qualsiasi spazio di lavoro che condivida il metastore.

  • L'identità Azure della credenziale di servizio è autorizzata a richiamare le distribuzioni di Azure OpenAI o Microsoft Foundry che prevedi di interrogare. Per creare credenziali del servizio, vedere Creare credenziali del servizio.

I chiamanti che interrogano il fornitore hanno bisogno delle stesse sovvenzioni di qualsiasi altro fornitore. Non hanno bisogno di alcun privilegio sulla credenzia, ed è proprio questo che la tiene fuori dalla loro portata.

Il servizio di fornitore modello traccia una credenziale tramite il suo identificatore interno, così puoi rinominarla senza fallimento della querit.

Se elimini una credenziale, le query non vengono eseguite e non viene visualizzato alcun avviso che indichi che un servizio del provider di modelli fa riferimento ad essa. Conferma che non ci siano riferimenti a questa credenziali prima di cancellarla.

Non puoi cambiare un servizio di fornitore modello esistente tra credenziale di servizio e chiave API o autenticazione segreta client. Crea invece un nuovo modello di servizio fornitore.

Invia una chiave API personalizzata del provider nell'intestazione

Un provider personalizzato invia la propria chiave API come token portatore di default. Quando il tuo endpoint prevede che la chiave venga passata in uno specifico header, usa l'autenticazione tramite header API key e specifica tu stesso il nome dell'header. Azure Databricks invia quindi la chiave su ogni richiesta in uscita come <header name>: <header value>.

Crea il servizio fornitore modello come descritto in Crea un servizio fornitore modello. Seleziona Personalizzato come tipo di fornitore, poi imposta il metodo Auth su API key header e fornisci il nome Header che il tuo endpoint si aspetta (come X-API-Key o Ocp-Apim-Subscription-Key) insieme al valore Header.

I due metodi sono mutuamente esclusivi: un provider personalizzato utilizza o un token portatore o un'intestazione nominata, non entrambi. L'autenticazione dell'intestazione richiede esattamente un'intestazione.

Il nome dell'intestazione deve essere un nome valido per l'intestazione HTTP: lettere, cifre e i caratteri !#$%&'*+-.^_`|~, fino a 255 caratteri. Qualsiasi altro carattere viene rifiutato, inclusi spazi, due punti, barre e interruzioni di riga.

Supporta una credenziale di fornitore con un segreto del Catalogo Unity

Invece di memorizzare una credenziale del fornitore in linea, puoi indirizzare un servizio modello di fornitore a un segreto del Catalogo Unity di proprietà del cliente che ne detiene il valore. Azure Databricks legge il segreto in fase di query utilizzando i diritti di accesso del proprietario del servizio del provider di modelli e non copia mai il valore nel servizio del provider di modelli, quindi la rotazione del segreto ha effetto senza alcuna modifica al servizio del provider di modelli.

Questo vale per qualsiasi fornitore la cui credenziale sia un unico valore inline: OpenAI, Azure OpenAI, Anthropic, Amazon Bedrock, Amazon Bedrock Mantle, Microsoft Foundry, Google Gemini Enterprise e Custom.

Crea il servizio fornitore modello come descritto in Crea un servizio fornitore modello. Seleziona il tipo di fornitore e inserisci i dettagli della sua connessione. Per la credenziale (come la chiave API), cambia il tipo di autenticazione da Testo in chiaro a Segreto, poi seleziona il catalogo, lo schema e il segreto che identificano il segreto del tuo Catalogo Unity.

Verificare i requisiti seguenti:

  • Il proprietario del servizio di fornitori modello ha READ SECRET il segreto del Catalogo Unity. Poiché Azure Databricks ricontrolla l'accesso del proprietario quando gestisce le richieste, il proprietario deve conservarlo finché il provider è in uso. La revoca interrompe le query per tutti, anche per i chiamanti che mantengono un EXECUTE sul provider. Per concedere al proprietario l'accesso al segreto:

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

  • Il segreto di Unity Catalog esiste prima di farvi riferimento. Per creare e governare i segreti del Catalogo Unity, vedi Segreti nel Catalogo Unity.

I chiamanti che interrogano il fornitore hanno bisogno delle stesse sovvenzioni di qualsiasi altro fornitore. Non hanno bisogno di alcun privilegio sul segreto del Catalogo Unità, che è ciò che tiene il valore segreto fuori dalla loro portata.

Per ruotare la credenziale, aggiorna il valore del segreto del Catalogo Unity, senza modificare il servizio del fornitore modello.

Se elimini il segreto del Catalogo Unity, le query falliscono. Il servizio del fornitore modello mantiene il riferimento ormai rotto così puoi vedere la dipendenza, e puoi ripristinare il provider aggiornandolo per fare riferimento a un segreto che esiste ancora.

Eliminare un servizio di fornitore modello non cancella mai il segreto del Catalogo Unity a cui fa riferimento.

Concedere l'accesso a un servizio di fornitore modello

Per impostazione predefinita, solo il proprietario del servizio del fornitore modello può interrogarla. Per consentire ad altri di interrogare un servizio provider del modello, concedi loro EXECUTE su di esso, oltre a USE CATALOG e USE SCHEMA sul relativo catalogo e schema. Se il servizio provider di modelli accede a una tabella di inferenza, concedere SELECT alla tabella per consentire loro di leggere le richieste e le risposte registrate.

Interfaccia utente

  1. Apri il servizio del fornitore modello in Catalog Explorer, oppure vai su AI Gateway e seleziona il servizio.
  2. Passare alla scheda Autorizzazioni .
  3. Fare clic su "Concedi".
  4. Selezionare gli utenti, i gruppi o le entità servizio a cui concedere l'accesso.
  5. Selezionare il privilegio EXECUTE .
  6. Fare clic su "Concedi".

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"] }
    ]
  }'

CLI

Concedi EXECUTE con la CLI di Databricks. Per installare la CLI, vedi Installa o aggiorna la CLI Databricks.

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

Terraform

Grant EXECUTE con il fornitore Databricks Terraform e la databricks_grant risorsa:

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

DAB (Beta)

Aggiungi un grants blocco alla risorsa di servizio del fornitore modello nel tuo bundle e ridistribuisci per concedere l'accesso.

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

Concedere EXECUTE con SDK Databricks per 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])],
)

SDK di sviluppo Go

Concedere EXECUTE con l'SDK di Databricks per Go:

_, 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

Concedere EXECUTE con l'SDK di Databricks per Java:

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)))));

Per maggiori informazioni sulla concessione e la scoperta dell'accesso, vedi Scopri e regoli l'accesso a fornitori modello esterni (servizi fornitori modello).

Configurare le funzionalità

Poiché un fornitore modello instrada il servizio tramite Unity Gateway, applica le stesse funzionalità di governance e osservabilità che usi per altri traffici Unity Gateway:

Configura un moltiplicatore di prezzo

Di default, Azure Databricks stima la spesa per modelli esterni utilizzando i prezzi di lista pubblicati dal fornitore. Se il prezzo del tuo fornitore differisce, configura un moltiplicatore di prezzo per riflettere sconti o margini. Ad esempio, 0.8 utilizza l'80% del prezzo di listino, mentre 1.2 ne utilizza 120%.

  1. Crea un servizio fornitore modello o apri un servizio fornitore modello esistente in Catalog Explorer o AI Gateway e clicca su Modifica.
  2. Espandi Opzioni avanzate.
  3. Inserisci un moltiplicatore di prezzo.
  4. Clicca su Crea o salva.

Campo moltiplicatore di prezzo sotto Opzioni avanzate nel dialogo Crea modello di servizio fornitore

Il moltiplicatore si applica a tutti i modelli disponibili tramite il servizio di fornitore di modelli. La spesa calcolata in system.ai_gateway.external_model_spend riflette il moltiplicatore configurato. Le modifiche si applicano alle richieste effettuate dopo che la configurazione è entrata in vigore; le richieste precedenti rimangono stimate utilizzando il prezzo di lista o il moltiplicatore precedentemente configurato.

Un moltiplicatore configurato mostra un tag di prezzo personalizzato . I prezzi aggiustati hanno una linea punteggiata nelle tabelle dei prezzi. Passa il mouse su un prezzo aggiustato per confrontarlo con quello di listino del fornitore.

Configura le rotte endpoint per un provider personalizzato

Le route dell'endpoint sono opzionali. Usali nei casi in cui un provider personalizzato ospita modelli diversi in percorsi diversi sotto lo stesso base_url. Un modello può supportare più tipi di API. Ogni modello ha una rotta endpoint condivisa dai tipi di API supportati.

Per configurare un percorso, imposta endpoint_route sul target su un percorso relativo, non un URL completo. Unity Gateway aggiunge la rotta alla fine di base_url, dopo qualsiasi percorso che base_url già contiene.

Interfaccia utente

  1. Apri la finestra di dialogo Crea servizio provider modello come descritto in Crea un servizio provider modello e seleziona Personalizzato nella sezione Provider.
  2. Nella sezione Modelli, inserisci il nome di un modello, seleziona i tipi di API che il modello supporta e inserisci un percorso relativo in Endpoint route (opzionale).
  3. Clicca Aggiungi modello. Ripeti per ogni modello.
  4. Clicca su Crea.

REST API

La seguente richiesta configura percorsi separati per un modello di chat e un modello di embedding:

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" }
      }
    }
  }
}'

Con questo base_url, le richieste utilizzano i seguenti URL a monte:

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

Se ometti endpoint_route o la imposti su una stringa vuota, Unity Gateway usa base_url invariata.

native_api_types mostra la traduzione API per ogni modello. Non seleziona né cambia la route upstream.

Aggiorna un servizio di fornitore modello

Devi essere proprietario o avere MANAGE. Il tipo di fornitore è immutabile.

Interfaccia utente

Modifica la configurazione del servizio del provider del modello dall'interfaccia utente di Unity Gateway o da Catalog Explorer. Le modifiche vengono applicate direttamente.

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"}'

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

Modifica comment (o qualsiasi altro campo mutabile) sulla databricks_ai_gateway_model_provider_service risorsa e riapplica. Le modifiche vengono applicate direttamente.

DAB (Beta)

Modifica comment (o qualsiasi altro campo mutabile) nella risorsa bundle ed esegui databricks bundle deploy. Le modifiche vengono applicate direttamente.

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"
    ),
)

SDK di sviluppo Go

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")));

SDK modulare JS

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'),
});

Eliminare un servizio provider di modelli

Devi essere proprietario o avere MANAGE.

Interfaccia utente

Apri il servizio del fornitore modello nell'interfaccia utente Unity Gateway o nell'Esplora cataloghi e seleziona Elimina dal menu kebab.

REST API

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

CLI

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

Terraform

Esegui terraform destroy, oppure rimuovi il blocco risorsa e riapplica.

DAB (Beta)

Rimuovi la risorsa dal bundle e corri databricks bundle deploy per eliminarla. databricks bundle destroy Funziona anche, ma rimuove tutte le risorse gestite dal bundle, non solo questa.

PYTHON SDK

w.ai_gateway.delete_model_provider_service(
    name="model-provider-services/main.default.my_provider"
)

SDK di sviluppo Go

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"));

SDK modulare JS

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

Passaggi successivi

  • Ultimo aggiornamento: