Integrera AI-modeller och externa tjänster på ett säkert sätt

9 minuter

SQL Server 2025 har inbyggt stöd för anslutning till externa AI-modeller och tjänster direkt från T-SQL. Den här integreringen eliminerar komplexiteten i att hantera separat infrastruktur samtidigt som säkerhet och efterlevnadsstandarder i företagsklass upprätthålls.

Möjligheten att ansluta SQL Server till externa AI-tjänster innebär att du kan använda modeller från Azure OpenAI, anpassade ONNX-modeller eller någon REST-baserad AI-slutpunkt utan att flytta dina data från databasen. Den här metoden skyddar dina data, minskar svarstiden och förenklar din programarkitektur genom att centralisera AI-åtgärder inom din dataplattform.

Ansluta till externa AI-modeller med hjälp av REST-API:er

SQL Server 2025 bygger på den sp_invoke_external_rest_endpoint system lagrade proceduren (introducerades i SQL Server 2022) för att möjliggöra integrering med AI-tjänster. Med den här funktionen kan du anropa REST-API:er direkt från T-SQL för integrering med AI-tjänster som Azure OpenAI, Microsoft Foundry och anpassade AI-slutpunkter utan att lämna databaskontexten.

Anropa REST-slutpunkter för AI-slutsatsdragning

Det grundläggande mönstret för att anropa en extern AI-tjänst är att skapa en JSON-nyttolast och skicka den till en REST-slutpunkt:

DECLARE @url NVARCHAR(4000) = N'https://myopenai.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2023-05-15';
DECLARE @payload NVARCHAR(MAX) = JSON_OBJECT('input': N'SQL Server 2025 AI capabilities');
DECLARE @response NVARCHAR(MAX);
DECLARE @ret INT;

EXEC @ret = sp_invoke_external_rest_endpoint
    @url = @url,
    @method = 'POST',
    @credential = [MyAzureOpenAICredential],
    @payload = @payload,
    @response = @response OUTPUT;

-- Extract the embedding from the response
DECLARE @embedding VECTOR(1536) = JSON_QUERY(@response, '$.result.data[0].embedding');
SELECT @embedding AS generated_embedding;

Den här koden skickar en textsträng till Azure OpenAI:s inbäddningsslutpunkt och hämtar en vektorinbäddning . Proceduren sp_invoke_external_rest_endpoint hanterar autentisering med hjälp av en databasomfattande autentiseringsuppgift, kör HTTP-begäran och returnerar svaret som JSON. Inbäddningen extraheras sedan med hjälp av JSON_QUERY och castas till vektordatatypen för lagring eller vidare bearbetning.

Använda databasautentiseringsuppgifter på ett säkert sätt

Om du vill anropa externa tjänster på ett säkert sätt kan du skapa autentiseringsuppgifter med databasomfattning som lagrar autentiseringsinformation:

-- Create a credential for Azure OpenAI
CREATE DATABASE SCOPED CREDENTIAL [MyAzureOpenAICredential]
WITH IDENTITY = 'HTTPEndpointHeaders',
SECRET = '{"api-key":"your-api-key-here"}';

Den här autentiseringsuppgiften lagrar API-nyckeln på ett säkert sätt i SQL Server och kan refereras i REST-slutpunktsanrop. Autentiseringsuppgifterna är krypterade och är endast tillgängliga för behöriga användare, vilket säkerställer att känslig autentiseringsinformation inte exponeras i programkoden.

Hantera externa AI-modeller med `CREATE EXTERNAL MODEL`

SQL Server 2025 introducerar ny syntax för att hantera AI-modelldefinitioner direkt i databasen. Med instruktionen CREATE EXTERNAL MODEL kan du definiera modellslutpunkter, autentiseringsmetoder och syften på ett centraliserat och återanvändbart sätt.

Definiera externa modellobjekt

Skapa ett externt modellobjekt för att kapsla in anslutningsinformationen för en AI-tjänst:

CREATE EXTERNAL MODEL Ada2Embeddings
WITH (
    LOCATION = 'https://myopenai.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2023-05-15',
    API_FORMAT = 'Azure OpenAI',
    MODEL_TYPE = EMBEDDINGS,
    MODEL = 'text-embedding-ada-002',
    CREDENTIAL = [MyAzureOpenAICredential]
);

Detta skapar en återanvändbar modelldefinition med namnet Ada2Embeddings som pekar på en Inbäddningsmodell för Azure OpenAI. Genom att definiera modellen en gång kan du använda den i hela databasen utan att upprepa anslutningsinformationen, vilket gör underhåll enklare och minskar risken för konfigurationsfel.

Generera inbäddningar med hjälp av externa modeller

När en extern modell har definierats kan du använda AI_GENERATE_EMBEDDINGS med funktionen:

DECLARE @text NVARCHAR(MAX) = N'SQL Server 2025 enables AI-powered applications';
DECLARE @embedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@text USE MODEL Ada2Embeddings);

INSERT INTO documents (title, content, embedding)
VALUES (N'Getting Started', @text, @embedding);

Den här koden genererar en inbäddning för den angivna texten med hjälp av modellen Ada2Embeddings och lagrar den i dokumenttabellen. Funktionen AI_GENERATE_EMBEDDINGS sammanfattar komplexiteten i att göra REST-anrop och parsa svar, vilket ger ett enkelt, SQL-inbyggt sätt att generera inbäddningar.

Ändra och ta bort externa modeller

Du kan uppdatera eller ta bort externa modelldefinitioner när dina krav ändras:

-- Alter an existing external model
ALTER EXTERNAL MODEL Ada2Embeddings
SET LOCATION = 'https://newendpoint.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2023-05-15';

-- Drop an external model when no longer needed
DROP EXTERNAL MODEL Ada2Embeddings;

Med instruktionen ALTER EXTERNAL MODEL kan du uppdatera modellkonfigurationer utan att återskapa beroende objekt. När en modell inte längre behövs, tar DROP EXTERNAL MODEL bort definitionen fullständigt från databasen.

Implementera säkra autentiseringsmönster

När du integrerar med externa tjänster tillhandahåller SQL Server 2025 flera autentiseringsmekanismer för att säkerställa säker och kompatibel åtkomst till AI-tjänster.

Använda hanterade identiteter med Microsoft Entra

Hanterade identiteter eliminerar behovet av att lagra autentiseringsuppgifter med hjälp av Azures identitetsinfrastruktur. Med SQL Server aktiverat av Azure Arc kan du använda hanterade identiteter för både inkommande och utgående anslutningar:

-- Create a credential using managed identity
CREATE DATABASE SCOPED CREDENTIAL [AzureOpenAIManagedIdentity]
WITH IDENTITY = 'Managed Identity';

-- Use the managed identity credential with external models
CREATE EXTERNAL MODEL SecureEmbeddingModel
WITH (
    LOCATION = 'https://myopenai.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2023-05-15',
    API_FORMAT = 'Azure OpenAI',
    MODEL_TYPE = EMBEDDINGS,
    MODEL = 'text-embedding-ada-002',
    CREDENTIAL = [AzureOpenAIManagedIdentity]
);

Den här metoden använder den hanterade identitet som tilldelats SQL Server-instansen för autentisering, vilket eliminerar behovet av att hantera API-nycklar eller lösenord. Azure-plattformen hanterar rotation av autentiseringsuppgifter och åtkomsthantering, vilket minskar säkerhetsrisker och administrativa kostnader.

Integrera med Foundry Tools

SQL Server 2025 integreras med hela paketet Foundry Tools, vilket möjliggör AI-scenarier direkt från databasen.

Ansluta till Azure OpenAI-tjänsten

Azure OpenAI ger åtkomst till språkmodeller som GPT-4, GPT-3.5 och inbäddningsmodeller:

-- Create a model for GPT-4
CREATE EXTERNAL MODEL GPT4Model
WITH (
    LOCATION = 'https://myopenai.openai.azure.com/openai/deployments/gpt-4/chat/completions?api-version=2024-02-15-preview',
    API_FORMAT = 'Azure OpenAI',
    MODEL_TYPE = EMBEDDINGS,
    MODEL = 'gpt-4',
    CREDENTIAL = [MyAzureOpenAICredential]
);

-- Use GPT-4 for text generation via REST endpoint
DECLARE @prompt NVARCHAR(MAX) = JSON_OBJECT(
    'messages': JSON_ARRAY(
        JSON_OBJECT('role': 'system', 'content': 'You are a helpful assistant'),
        JSON_OBJECT('role': 'user', 'content': 'Explain vector search in simple terms')
    )
);
DECLARE @response NVARCHAR(MAX);

EXEC sp_invoke_external_rest_endpoint
    @url = N'https://myopenai.openai.azure.com/openai/deployments/gpt-4/chat/completions?api-version=2024-02-15-preview',
    @method = 'POST',
    @credential = [MyAzureOpenAICredential],
    @payload = @prompt,
    @response = @response OUTPUT;

SELECT JSON_VALUE(@response, '$.result.choices[0].message.content') AS ai_response;

Det här exemplet skapar en extern modelldefinition för GPT-4 och visar hur du anropar API:et för chattens slutförande. Svaret parsas med hjälp av JSON-funktioner för att extrahera den AI-genererade texten, som sedan kan användas i din programlogik eller lagras för senare användning.

Använda Microsoft Foundry

Microsoft Foundry tillhandahåller en omfattande plattform för att skapa, träna och distribuera anpassade AI-modeller som uppfyller specifika affärskrav utöver vad allmänna modeller kan erbjuda. Azure OpenAI ger åtkomst till förtränade modeller som GPT-4 och textinbäddning-ada-002, men Med Microsoft Foundry kan du skapa specialiserade modeller som tränats på dina egna data, branschspecifik terminologi och unika användningsfall.

Med integreringen mellan SQL Server 2025 och Microsoft Foundry kan du ta med domänspecifik intelligens direkt till dina data utan dataflytt eller synkronisering. Du kan till exempel träna en anpassad klassificeringsmodell för att kategorisera kundsupportärenden baserat på företagets specifika produkter och tjänster, eller skapa en attitydanalysmodell som är anpassad efter branschens språkmönster. När de har distribuerats i Microsoft Foundry blir dessa modeller tillgängliga via samma CREATE EXTERNAL MODEL syntax som du använder för Azure OpenAI.

-- Connect to a custom classification model in Microsoft Foundry
CREATE EXTERNAL MODEL CustomClassifier
WITH (
    LOCATION = 'https://myaifoundry.cognitiveservices.azure.com/models/classifier/predict?api-version=1.0',
    API_FORMAT = 'Azure OpenAI',
    MODEL_TYPE = EMBEDDINGS,
    MODEL = 'classifier',
    CREDENTIAL = [AzureAIFoundryCredential]
);

-- Use the custom model for domain-specific predictions
DECLARE @input_text NVARCHAR(MAX) = N'Customer reports slow query performance in production database';
DECLARE @request NVARCHAR(MAX) = JSON_OBJECT('input': @input_text);
DECLARE @response NVARCHAR(MAX);

EXEC sp_invoke_external_rest_endpoint
    @url = N'https://myaifoundry.cognitiveservices.azure.com/models/classifier/predict?api-version=1.0',
    @method = 'POST',
    @credential = [AzureAIFoundryCredential],
    @payload = @request,
    @response = @response OUTPUT;

-- Extract classification result
SELECT JSON_VALUE(@response, '$.result.category') AS ticket_category,
       JSON_VALUE(@response, '$.result.priority') AS priority_level;

Med den här metoden kan du upprätthålla en enda sanningskälla för dina data i SQL Server samtidigt som du använder AI-funktioner som förstår din specifika affärskontext. Fördelen sträcker sig bortom teknisk bekvämlighet: genom att behålla dina data i SQL Server och anropa AI-modeller via säkra API-slutpunkter har du fullständig kontroll över principer för datastyrning, efterlevnad och åtkomst. Dina känsliga affärsdata behöver aldrig lämna databasinfrastrukturen, men du kan fortfarande använda AI-modeller som har tränats för att förstå dina unika krav.

Distribuera ONNX-modeller

Open Neural Network Exchange (ONNX) är en öppen standard för att representera maskininlärningsmodeller. SQL Server 2025 stöder ONNX-körning så att du kan distribuera anpassade modeller lokalt.

Använd ONNX-runtime för lokal inferens

ONNX-modeller kan köras direkt i SQL Server utan externa beroenden:

-- Reference a local ONNX model file
CREATE EXTERNAL MODEL LocalSentimentModel
WITH (
    LOCATION = 'C:\Models\sentiment_analysis',
    API_FORMAT = 'ONNX Runtime',
    MODEL_TYPE = EMBEDDINGS,
    MODEL = 'sentiment-model',
    LOCAL_RUNTIME_PATH = 'C:\onnx_runtime\'
);

Den här metoden passar scenarier där du behöver slutsatsdragning med låg svarstid, vill undvika externa nätverksanrop eller har efterlevnadskrav som förhindrar att data lämnar infrastrukturen. LOCATION Ska peka på katalogen som innehåller filerna model.onnx och tokenizer.json, medan LOCAL_RUNTIME_PATH pekar på katalogen som innehåller DLL-filerna för ONNX-körning.

Tillämpa metodtips för säkerhet

När du integrerar AI-tjänster med SQL Server följer du dessa säkerhetsriktlinjer:

Kontrollera åtkomst med behörigheter

Bevilja behörigheter till externa modellobjekt noggrant:

-- Grant permission to use an external model
GRANT EXECUTE ON EXTERNAL MODEL::Ada2Embeddings TO AIApplicationUser;

-- Revoke permissions when no longer needed
REVOKE EXECUTE ON EXTERNAL MODEL::Ada2Embeddings FROM AIApplicationUser;

Dessa instruktioner styr vilka användare och roller som kan använda specifika externa modeller, vilket möjliggör detaljerad åtkomstkontroll över AI-funktioner.

Aktivera granskning och övervakning

Spåra AI-åtgärder för efterlevnad och felsökning:

-- Create an audit specification for external REST endpoint calls
CREATE SERVER AUDIT SPECIFICATION TrackAIOperations
FOR SERVER AUDIT [MyServerAudit]
ADD (DATABASE_OBJECT_ACCESS_GROUP);

Granskning samlar in alla interaktioner med externa modeller och REST-slutpunkter, vilket ger insyn i AI-användningsmönster och stöd för efterlevnadskrav.

Genom att implementera dessa säkra integrationsmönster kan du distribuera AI-baserade lösningar med SQL Server 2025 som uppfyller företagets krav på säkerhet, efterlevnad och styrning.

Feedback

Var den här sidan till hjälp?