Zarządzanie punktami końcowymi obsługującymi model

W tym artykule opisano sposób zarządzania punktami końcowymi obsługującymi model przy użyciu interfejsu użytkownika obsługującego i interfejsu API REST. Zobacz Obsługa punktów końcowych w dokumentacji interfejsu API REST.

Aby utworzyć model obsługujący punkty końcowe, użyj jednego z następujących elementów:

• Tworzenie niestandardowych punktów końcowych obsługujących model.
• Tworzenie modelu podstawowego obsługującego punkty końcowe.

Uzyskiwanie stanu punktu końcowego modelu

Stan punktu końcowego można sprawdzić przy użyciu interfejsu użytkownika obsługującego lub programowo przy użyciu interfejsu API REST, klienta obszaru roboczego usługi Databricks lub zestawu SDK wdrożeń MLflow.

Statusy punktów końcowych mogą być Ready, Ready (Update failed), Not ready (Updating), Not ready (Update failed) lub Not ready (Stopped). Gotowość odnosi się do tego, czy można zadawać zapytania punktowi końcowemu. Nieudana aktualizacja wskazuje, że ostatnia zmiana punktu końcowego się nie powiodła. Zatrzymano oznacza, że punkt końcowy został zatrzymany.

interfejs użytkownika

Wskaźnik stanu punktu końcowego obsługującego w górnej części strony szczegółów punktu końcowego:

interfejs API REST

GET /api/2.0/serving-endpoints/{name}

W poniższej przykładowej odpowiedzi state.ready pole jest "GOTOWE", co oznacza, że punkt końcowy jest gotowy do odbierania ruchu. Pole state.update_state jest NOT_UPDATING, a pending_config nie jest już zwracane, ponieważ aktualizacja została zakończona pomyślnie.

{
  "name": "unity-model-endpoint",
  "creator": "customer@example.com",
  "creation_timestamp": 1666829055000,
  "last_updated_timestamp": 1666829055000,
  "state": {
    "ready": "READY",
    "update_state": "NOT_UPDATING"
  },
  "config": {
    "served_entities": [
      {
        "name": "my-ads-model",
        "entity_name": "myCatalog.mySchema.my-ads-model",
        "entity_version": "1",
        "workload_size": "Small",
        "scale_to_zero_enabled": false,
        "state": {
          "deployment": "DEPLOYMENT_READY",
          "deployment_state_message": ""
        },
        "creator": "customer@example.com",
        "creation_timestamp": 1666829055000
      }
    ],
    "traffic_config": {
      "routes": [
        {
          "served_model_name": "my-ads-model",
          "traffic_percentage": 100
        }
      ]
    },
    "config_version": 1
  },
  "id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "permission_level": "CAN_MANAGE"
}

Klient obszaru roboczego usługi Databricks

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
endpoint = w.serving_endpoints.get(name="my-endpoint")
print(f"Endpoint state: {endpoint.state.ready}")
print(f"Update state: {endpoint.state.config_update}")

Zestaw SDK wdrożeń MLflow

from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.get_endpoint(endpoint="my-endpoint")
print(f"Endpoint state: {endpoint['state']}")
print(f"Endpoint config: {endpoint['config']}")

Zatrzymywanie punktu końcowego obsługującego model

Możesz tymczasowo zatrzymać punkt końcowy obsługujący model i uruchomić go później. Po zatrzymaniu punktu końcowego:

• Przeznaczone zasoby zostały zamknięte.
• Punkt końcowy nie może obsługiwać zapytań, dopóki nie zostanie uruchomiony ponownie.
• Można zatrzymać tylko punkty końcowe obsługujące modele niestandardowe i nie mają aktualizacji w toku.
• Zatrzymane punkty końcowe nie są liczone względem limitu przydziału zasobów.
• Zapytania wysyłane do zatrzymanego punktu końcowego zwracają błąd 400.

Zatrzymywanie punktu końcowego

interfejs użytkownika

Kliknij przycisk Zatrzymaj w prawym górnym rogu.

interfejs API REST

POST /api/2.0/serving-endpoints/{name}/config:stop

Uruchom punkt końcowy

Uruchomienie punktu końcowego powoduje utworzenie nowej wersji konfiguracji z tymi samymi właściwościami co istniejąca zatrzymana konfiguracja.

Gdy wszystko będzie gotowe do uruchomienia zatrzymanego modelu obsługującego punkt końcowy:

interfejs użytkownika

Kliknij przycisk Start w prawym górnym rogu.

interfejs API REST

POST /api/2.0/serving-endpoints/{name}/config:start

Usuwanie punktu końcowego obsługującego model

Usunięcie punktu końcowego powoduje wyłączenie użycia i usunięcie wszystkich danych skojarzonych z punktem końcowym. Nie można cofnąć usuwania.

interfejs użytkownika

Kliknij menu kebab u góry i wybierz pozycję Usuń.

interfejs API REST

DELETE /api/2.0/serving-endpoints/{name}

Zestaw SDK wdrożeń MLflow

from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
client.delete_endpoint(endpoint="chat")

Debugowanie punktu końcowego obsługującego model

Dostępne są dwa typy dzienników, które ułatwiają debugowanie problemów z punktami końcowymi:

• Dzienniki kompilacji kontenera serwera modelu: generowane podczas inicjowania punktu końcowego podczas tworzenia kontenera. Te dzienniki przechwytują fazę konfiguracji, w tym pobieranie modelu, instalowanie zależności i konfigurowanie środowiska uruchomieniowego. Użyj tych dzienników, aby debugować, dlaczego nie można uruchomić punktu końcowego lub jest zablokowany podczas wdrażania.
• Dzienniki serwera modelu: generowane podczas wykonywania, gdy punkt końcowy aktywnie obsługuje przewidywania. Te dzienniki przechwytują żądania przychodzące, wykonywanie inferencji modelu, błędy wykonawcze i rejestrowanie na poziomie aplikacji charakterystyczne dla kodu modelu. Użyj tych dzienników, aby debugować problemy z przewidywaniami lub badać błędy zapytań.

Oba typy dzienników są również dostępne z poziomu interfejsu użytkownika punktów końcowych na karcie Dzienniki .

Pobieranie dzienników kompilacji kontenera

W przypadku dzienników kompilacji dla obsługiwanego modelu można użyć następującego żądania. Aby uzyskać więcej informacji, zobacz Przewodnik debugowania obsługi modeli.

GET /api/2.0/serving-endpoints/{name}/served-models/{served-model-name}/build-logs
{
  "config_version": 1  // optional
}

Pobieranie dzienników serwera modelu

W przypadku dzienników serwera modelu dla modelu obsługującego można użyć następującego żądania:

GET /api/2.0/serving-endpoints/{name}/served-models/{served-model-name}/logs

{
  "config_version": 1  // optional
}

Zarządzanie uprawnieniami w punkcie końcowym obsługującym model

Aby zmodyfikować uprawnienia, musisz mieć co najmniej uprawnienie CAN MANAGE w punkcie końcowym obsługującym. Aby uzyskać więcej informacji na temat poziomów uprawnień, zobacz Obsługa list ACL punktów końcowych.

Pobierz listę uprawnień dotyczącą punktu końcowego obsługującego.

interfejs użytkownika

Kliknij przycisk Uprawnienia w prawym górnym rogu interfejsu użytkownika.

Interfejs CLI usługi Databricks

databricks permissions get serving-endpoints <endpoint-id>

Udziel użytkownikowi jsmith@example.com uprawnienia CAN QUERY na końcowym punkcie obsługi.

databricks permissions update serving-endpoints <endpoint-id> --json '{
  "access_control_list": [
    {
      "user_name": "jsmith@example.com",
      "permission_level": "CAN_QUERY"
    }
  ]
}'

Możesz również zmodyfikować uprawnienia obsługujące punkty końcowe przy użyciu interfejsu API uprawnień.

Dodawanie zasad budżetu bezserwerowych dla punktu końcowego obsługującego model

Bezserwerowe zasady budżetu umożliwiają organizacji stosowanie tagów niestandardowych dla użytkowania bezserwerowego na potrzeby szczegółowego przypisywania kosztów. Jeśli obszar roboczy używa bezserwerowych zasad budżetu do przypisywania użycia bezserwerowego, możesz dodać do modelu zasady budżetu obsługujące punkty końcowe. Zobacz Użycie atrybutów w zasadach budżetu bezserwerowego.

Podczas tworzenia punktu końcowego obsługującego model można wybrać bezserwerowe zasady budżetu punktu końcowego z menu Zasady budżetu w interfejsie użytkownika obsługującego. Jeśli masz przypisane zasady budżetu bezserwerowego, wszystkie utworzone punkty końcowe są przypisane do tych bezserwerowych zasad budżetu, nawet jeśli nie wybierzesz zasad z menu Zasad budżetu .

Jeśli masz MANAGE uprawnienia do istniejącego punktu końcowego, możesz edytować i dodać politykę budżetową dla rozwiązań bezserwerowych do tego punktu końcowego na stronie Szczegóły punktu końcowego w interfejsie użytkownika.

Pobierz schemat punktu końcowego obsługującego model

Schemat zapytania obsługującego punkt końcowy jest formalnym opisem punktu końcowego obsługującego przy użyciu standardowej specyfikacji interfejsu OpenAPI w formacie JSON. Zawiera on informacje o punkcie końcowym, w tym ścieżkę punktu końcowego, szczegóły dotyczące wykonywania zapytań dotyczących punktu końcowego, takiego jak format treści żądania i odpowiedzi, oraz typ danych dla każdego pola. Te informacje mogą być przydatne w scenariuszach powtarzalności lub gdy potrzebujesz informacji o punkcie końcowym, ale nie jesteś oryginalnym twórcą ani właścicielem punktu końcowego.

Aby uzyskać schemat punktu końcowego obsługującego model, obsługiwany model musi mieć zarejestrowany podpis modelu, a punkt końcowy musi być w stanie READY.

W poniższych przykładach pokazano, jak programowo pobrać schemat punktu końcowego obsługującego model przy użyciu interfejsu API REST. Aby uzyskać informacje na temat schematów punktów końcowych obsługujących funkcje, zobacz Funkcje obsługujące punkty końcowe.

Schemat zwracany przez interfejs API jest w formacie obiektu JSON zgodnego ze specyfikacją interfejsu OpenAPI.

ACCESS_TOKEN="<endpoint-token>"
ENDPOINT_NAME="<endpoint name>"

curl "https://example.databricks.com/api/2.0/serving-endpoints/$ENDPOINT_NAME/openapi" -H "Authorization: Bearer $ACCESS_TOKEN" -H "Content-Type: application/json"

Szczegóły schematu odpowiedzi

Odpowiedź jest specyfikacją interfejsu OpenAPI w formacie JSON, zazwyczaj obejmującą pola, takie jak openapi, infoservers i paths. Ponieważ odpowiedź schematu jest obiektem JSON, możesz przeanalizować go przy użyciu typowych języków programowania i wygenerować kod klienta ze specyfikacji przy użyciu narzędzi innych firm. Można również wizualizować specyfikację interfejsu OpenAPI przy użyciu narzędzi innych firm, takich jak Edytor struktury Swagger.

Główne pola odpowiedzi to:

• Pole info.title zawiera nazwę punktu końcowego obsługującego.
• Pole servers zawsze zawiera jeden obiekt, zazwyczaj url pole, które jest podstawowym adresem URL punktu końcowego.
• Obiekt paths w odpowiedzi zawiera wszystkie obsługiwane ścieżki dla punktu końcowego. Klucze w obiekcie są adresem URL ścieżki. Każdy path może obsługiwać wiele formatów danych wejściowych. Te dane wejściowe są wyświetlane w oneOf polu.

Poniżej przedstawiono przykładową odpowiedź schematu punktu końcowego:

{
  "openapi": "3.1.0",
  "info": {
    "title": "example-endpoint",
    "version": "2"
  },
  "servers": [{ "url": "https://example.databricks.com/serving-endpoints/example-endpoint" }],
  "paths": {
    "/served-models/vanilla_simple_model-2/invocations": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "type": "object",
                    "properties": {
                      "dataframe_split": {
                        "type": "object",
                        "properties": {
                          "columns": {
                            "description": "required fields: int_col",
                            "type": "array",
                            "items": {
                              "type": "string",
                              "enum": ["int_col", "float_col", "string_col"]
                            }
                          },
                          "data": {
                            "type": "array",
                            "items": {
                              "type": "array",
                              "prefixItems": [
                                {
                                  "type": "integer",
                                  "format": "int64"
                                },
                                {
                                  "type": "number",
                                  "format": "double"
                                },
                                {
                                  "type": "string"
                                }
                              ]
                            }
                          }
                        }
                      },
                      "params": {
                        "type": "object",
                        "properties": {
                          "sentiment": {
                            "type": "number",
                            "format": "double",
                            "default": "0.5"
                          }
                        }
                      }
                    },
                    "examples": [
                      {
                        "columns": ["int_col", "float_col", "string_col"],
                        "data": [
                          [3, 10.4, "abc"],
                          [2, 20.4, "xyz"]
                        ]
                      }
                    ]
                  },
                  {
                    "type": "object",
                    "properties": {
                      "dataframe_records": {
                        "type": "array",
                        "items": {
                          "required": ["int_col", "float_col", "string_col"],
                          "type": "object",
                          "properties": {
                            "int_col": {
                              "type": "integer",
                              "format": "int64"
                            },
                            "float_col": {
                              "type": "number",
                              "format": "double"
                            },
                            "string_col": {
                              "type": "string"
                            },
                            "becx_col": {
                              "type": "object",
                              "format": "unknown"
                            }
                          }
                        }
                      },
                      "params": {
                        "type": "object",
                        "properties": {
                          "sentiment": {
                            "type": "number",
                            "format": "double",
                            "default": "0.5"
                          }
                        }
                      }
                    }
                  }
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful operation",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "predictions": {
                      "type": "array",
                      "items": {
                        "type": "number",
                        "format": "double"
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}