sp_invoke_external_rest_endpoint (Transact-SQL)

Gäller för: SQL Server 2025 (17.x) Förhandsversion av Azure SQL DatabaseAzure SQL Managed InstanceSQL Database i Förhandsversion av Microsoft Fabric

Den sp_invoke_external_rest_endpoint lagrade proceduren anropar en HTTPS REST-slutpunkt som anges som ett indataargument till proceduren.

Sätt att minska risken för obehörig åtkomst eller överföring av data

För att minska risken för obehörig åtkomst eller överföring av data bör du överväga följande metodtips för säkerhet:

• Implementera starka åtkomstkontroller: Se till att endast behöriga användare har åtkomst till känsliga data och REST API-slutpunkter. Använd principen om minsta behörighet, samt databasroller och behörigheter.
• Korrekt autentisering och auktorisering: Kontrollera att alla REST-anrop autentiseras och har behörighet att förhindra obehörig åtkomst.
• Övervaka och granska åtkomst: Övervaka och granska regelbundet åtkomsten till databasen och REST API-anrop för att identifiera misstänkta aktiviteter.
• Regelbundna säkerhetsutvärderingar: Utför regelbundna säkerhetsbedömningar och sårbarhetsgenomsökningar för att identifiera och minimera potentiella risker.
• Medarbetarutbildning: Utbilda anställda om riskerna med dataexfiltrering och vikten av att följa säkerhetsprotokoll.

Syntax

Transact-SQL syntaxkonventioner

EXECUTE @returnValue = sp_invoke_external_rest_endpoint
  [ @url = ] N'url'
  [ , [ @payload = ] N'request_payload' ]
  [ , [ @headers = ] N'http_headers_as_json_array' ]
  [ , [ @method = ] 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' ]
  [ , [ @timeout = ] seconds ]
  [ , [ @credential = ] credential ]
  [ , @response OUTPUT ]
  [ , [ @retry_count = ] # of retries if there are errors ] 

Arguments

[ @url = ] N'url'

URL för HTTPS REST-slutpunkten som ska anropas. @url är nvarchar(4000) utan standard.

[ @payload = ] N'request_payload'

Unicode-sträng i ett JSON-, XML- eller TEXT-format som innehåller nyttolasten som ska skickas till HTTPS REST-slutpunkten. Nyttolaster måste vara ett giltigt JSON-dokument, ett välformat XML-dokument eller text. @payload är nvarchar(max) utan standard.

[ @headers = ] N"rubriker"

Rubriker som måste skickas som en del av begäran till HTTPS REST-slutpunkten. Rubriker måste anges med ett platt JSON-format (ett JSON-dokument utan kapslade strukturer). Rubriker som definierats i listan Med namn på förbjudna rubriker ignoreras även om de uttryckligen skickas i parametern @headers . deras värden ignoreras eller ersätts med systembaserade värden när HTTPS-begäran startas.

Parametern @headers är nvarchar(4000) utan standard.

[ @method = ] Nmetod

HTTP-metod för att anropa URL:en. Måste vara något av följande värden: GET, POST, PUT, PATCH, DELETE, HEAD. @method är nvarchar(6) med POST som standardvärde.

[ @timeout = ] sekunder

Tid i sekunder tillåts för HTTPS-anropet att köras. Om den fullständiga HTTP-begäran och -svaret inte kan skickas och tas emot inom den definierade tidsgränsen på några sekunder stoppas körningen av den lagrade proceduren och ett undantag utlöses. Tidsgränsen startar när HTTP-anslutningen startar och slutar när svaret, och nyttolasten som ingår om någon, har tagits emot. @timeout är en positiv liten med standardvärdet 30. Godkända värden: 1 till 230.

Om parametern @retry_count anges fungerar parametern @timeout som den kumulativa tidsgränsen för proceduren.

[ @credential = ] autentiseringsuppgifter

Ange vilket DATABASE SCOPED CREDENTIAL-objekt som används för att mata in autentiseringsinformation i HTTPS-begäran. @credential är sysname utan standardvärde.

@response UTDATA

Tillåt att svaret som tas emot från den anropade slutpunkten skickas till den angivna variabeln. @response är nvarchar(max).

[ @retry_count = ] antal återförsök om det finns fel

Anger hur många gånger den lagrade proceduren försöker ansluta till den angivna slutpunkten om det uppstår ett fel. @retry_count är en positiv tinyint med standardvärdet 0. Godkända värden: 0 till 10, med 0 som kringgår all logik för återförsök. Återförsöksintervallet bestäms med rubriken Retry-After om det finns. Om huvudet saknas tillämpar systemet en exponentiell backoff-strategi för specifika felkoder. I alla andra fall används en standardfördröjning på 200 millisekunder.

Returvärde

Körningen returnerar 0 om HTTPS-anropet gjordes och HTTP-statuskoden som tas emot är en 2xx-statuskod (Success). Om HTTP-statuskoden som tas emot inte finns i 2xx-intervallet är returvärdet HTTP-statuskoden som tas emot. Om HTTPS-anropet inte kan utföras alls utlöses ett undantag.

Permissions

Databasbehörigheter

Kräver KÖR VALFRI EXTERN ENDPOINT-databasbehörighet.

Till exempel:

GRANT EXECUTE ANY EXTERNAL ENDPOINT TO [<PRINCIPAL>];

Aktivera i SQL Server 2025 och Azure SQL Managed Instance

Den sp_invoke_external_rest_endpoint lagrade proceduren är tillgänglig i SQL Server 2025 (17.x) Preview och Azure SQL Managed Instance med SQL Server 2025 eller Always-up-to-dateupdate policy och är inaktiverad som standard.

Om du vill aktivera den sp_invoke_external_rest_endpoint lagrade proceduren i SQL Server 2025 (17.x) Preview och Azure SQL Managed Instance kör du följande T-SQL-kod:

EXECUTE sp_configure 'external rest endpoint enabled', 1;

RECONFIGURE WITH OVERRIDE;

Om du vill köra sp_configure för att ändra ett konfigurationsalternativ eller för att köra RECONFIGURE-instruktionen måste en användare beviljas behörigheten ALTER SETTINGS på servernivå. Behörigheten ALTER SETTINGS innehas implicit av de fasta serverrollerna sysadmin och serveradmin.

Svarsformat

Svaret från HTTP-anropet och resulterande data som skickas tillbaka av den anropade slutpunkten är tillgängligt via parametern @response utdata. @response kan innehålla ett JSON-dokument med följande schema:

{
  "response": {
    "status": {
      "http": {
        "code": "",
        "description": ""
      }
    },
    "headers": {}
  },
  "result": {}
}

Specifically:

• svar: ett JSON-objekt som innehåller HTTP-resultatet och andra svarsmetadata.
• resultat: JSON-nyttolasten som returneras av HTTP-anropet. Utelämnas om det mottagna HTTP-resultatet är 204 (No Content).

Eller så kan @response innehålla ett XML-dokument med följande schema:

<output>
    <response>
        <status>
            <http code="" description=" " />
        </status>
        <headers>
            <header key="" value="" />
            <header key="" value="" />
        </headers>
    </response>
    <result>
    </result>
</output>

Specifically:

• svar: ett XML-objekt som innehåller HTTP-resultatet och andra svarsmetadata.
• resultat: XML-nyttolasten som returneras av HTTP-anropet. Utelämnas om det mottagna HTTP-resultatet är 204 (No Content).

I avsnittet response , förutom HTTP-statuskoden och beskrivningen, tillhandahålls hela uppsättningen med mottagna svarshuvuden headers i objektet. I följande exempel visas ett response avsnitt i JSON (även strukturen för textsvar):

"response": {
  "status": {
    "http": {
      "code": 200,
      "description": "OK"
    }
  },
  "headers": {
    "Date": "Thu, 08 Sep 2022 21:51:22 GMT",
    "Content-Length": "1345",
    "Content-Type": "application\/json; charset=utf-8",
    "Server": "Kestrel",
    "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
    }
  }

I följande exempel visas ett response avsnitt i XML:

<response>
    <status>
        <http code="200" description="OK" />
    </status>
    <headers>
        <header key="Date" value="Tue, 01 Apr 1976 21:12:04 GMT" />
        <header key="Content-Length" value="2112" />
        <header key="Content-Type" value="application/xml" />
        <header key="Server" value="Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0" />
        <header key="x-ms-request-id" value="31536000-64bi-64bi-64bi-31536000" />
        <header key="x-ms-version" value="2021-10-04" />
        <header key="x-ms-creation-time" value="Wed, 19 Apr 2023 22:17:33 GMT" />
        <header key="x-ms-server-encrypted" value="true" />
    </headers>
</response>

Tillåtna slutpunkter

Endast anrop till slutpunkter för följande tjänster tillåts:

Regler för utgående brandvägg för Azure SQL Database och Azure Synapse Analytics kontrollmekanism kan användas för att ytterligare begränsa utgående åtkomst till externa slutpunkter.

Limits

Nyttolaststorlek

Nyttolasten, både när den tas emot och när den skickas, kodas UTF-8 när den skickas via kabeln. I det formatet är dess storlek begränsad till 100 MB.

URL-längd

Den maximala URL-längden (som genereras efter användning av parametern @url och tillägg av angivna autentiseringsuppgifter i frågesträngen, om någon) är 8 KB. den maximala frågesträngslängden (frågesträng + frågesträng för autentiseringsuppgifter) är 4 KB.

Sidhuvudstorlek

Den maximala storleken på begäran och svarshuvud (alla rubrikfält: huvuden som skickas via @headers parameter + autentiseringshuvud + system angivna huvuden) är 8 KB.

Throttling

Antalet samtidiga anslutningar till externa slutpunkter som görs via sp_invoke_external_rest_endpoint begränsas till 10% arbetstrådar, med högst 150 arbetare. På en enskild databas tillämpas begränsning på databasnivå, och på en elastisk pool tillämpas begränsning både på databas- och poolnivå.

Kör följande fråga för att kontrollera hur många samtidiga anslutningar en databas kan upprätthålla:

SELECT [database_name],
       DATABASEPROPERTYEX(DB_NAME(), 'ServiceObjective') AS service_level_objective,
       [slo_name] AS service_level_objective_long,
       [primary_group_max_outbound_connection_workers] AS max_database_outbound_connection,
       [primary_pool_max_outbound_connection_workers] AS max_pool_outbound_connection
FROM sys.dm_user_db_resource_governance
WHERE database_id = DB_ID();

Oms fel 10928 (eller 10936 om du har nått gränser för elastiska pooler) om du försöker använda sp_invoke_external_rest_endpoint en ny anslutning till en extern slutpunkt när de maximala samtidiga anslutningarna redan har nåtts. Till exempel:

Msg 10928, Level 16, State 4, Procedure sys.sp_invoke_external_rest_endpoint_internal, Line 1 [Batch Start Line 0]
Resource ID : 1. The outbound connections limit for the database is 20 and has been reached.
See 'https://docs.microsoft.com/azure/azure-sql/database/resource-limits-logical-server' for assistance.

Credentials

Vissa REST-slutpunkter kräver autentisering för att kunna anropas korrekt. Autentisering kan vanligtvis göras genom att skicka vissa specifika nyckel/värde-par i frågesträngen eller i HTTP-huvudena som angetts med begäran.

Du kan använda DATABASE SCOPED CREDENTIAL för att lagra autentiseringsdata på ett säkert sätt (t.ex. en ägartoken) som ska användas av sp_invoke_external_rest_endpoint för att anropa en skyddad slutpunkt. När du skapar DATABASE SCOPED CREDENTIALanvänder du parametern IDENTITY för att ange vilka autentiseringsdata som skickas till den anropade slutpunkten och hur. IDENTITY stöder fyra alternativ:

• HTTPEndpointHeaders: skicka angivna autentiseringsdata med hjälp av begärandehuvuden
• HTTPEndpointQueryString: skicka angivna autentiseringsdata med hjälp av query string
• Managed Identity: skicka systemtilldelade hanterad identitet med hjälp av begärandehuvudena
• Shared Access Signature: ge begränsad delegerad åtkomst till resurser via en signerad URL- (kallas även SAS)

Den skapade DATABASE SCOPED CREDENTIAL kan användas via parametern @credential :

EXECUTE sp_invoke_external_rest_endpoint
    @url = N'https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?key1=value1',
    @credential = [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>];

CREATE DATABASE SCOPED CREDENTIAL [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>]
WITH IDENTITY = 'HTTPEndpointHeaders', SECRET = '{"x-functions-key":"<your-function-key-here>"}';

CREATE DATABASE SCOPED CREDENTIAL [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>]
WITH IDENTITY = 'HTTPEndpointQueryString', SECRET = '{"code":"<your-function-key-here>"}';

CREATE DATABASE SCOPED CREDENTIAL [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>]
WITH IDENTITY = 'Managed Identity', SECRET = '{"resourceid":"<APP_ID>"}';

EXECUTE sp_configure 'allow server scoped db credentials', 1;
RECONFIGURE WITH OVERRIDE;

Namnregler för autentiseringsuppgifter

Den skapade DATABASE SCOPED CREDENTIAL måste följa specifika regler för att kunna användas med sp_invoke_external_rest_endpoint. Reglerna är följande:

• Måste vara en giltig URL
• URL-domänen måste vara en av de domäner som ingår i listan över tillåtna domäner
• URL:en får inte innehålla en frågesträng
• Protokoll + Fullständigt domännamn (FQDN) för den anropade URL:en måste matcha Protokoll + FQDN för autentiseringsuppgiftsnamnet
• Varje del av den kallade URL-sökvägen måste matcha helt med respektive del av URL-sökvägen i autentiseringsuppgiftsnamnet
• Autentiseringsuppgifterna måste peka på en sökväg som är mer allmän än begärande-URL:en. Till exempel kan en autentiseringsuppgift som skapats för sökvägen https://northwind.azurewebsite.net/customers inte användas för URL-https://northwind.azurewebsite.net

Namnregler för sortering och autentiseringsuppgifter

RFC 3986 Avsnitt 6.2.2.1 säger att "När en URI använder komponenter i den generiska syntaxen gäller alltid reglerna för komponentsyntaxens likvärdighet. nämligen att systemet och värden är skiftlägesokänsliga", och RFC 7230 avsnitt 2.7.3 nämner att "alla andra jämförs på ett skiftlägeskänsligt sätt".

Eftersom det finns en sorteringsregel som har angetts på databasnivå tillämpas följande logik, så att den överensstämmer med databassorteringsregeln och RFC som nämns ovan. (Den beskrivna regeln kan potentiellt vara mer restriktiv än RFC-reglerna, till exempel om databasen är inställd på att använda en skiftlägeskänslig sortering.):

1. Kontrollera om URL:en och autentiseringsuppgifterna matchar med hjälp av RFC, vilket innebär:
   • Kontrollera schemat och värden med hjälp av en skiftlägesokänslig sortering (Latin1_General_100_CI_AS_KS_WS_SC)
   • Kontrollera att alla andra segment i URL:en jämförs i en skiftlägeskänslig sortering (Latin1_General_100_BIN2)
2. Kontrollera att URL:en och autentiseringsuppgifterna matchar med hjälp av databassorteringsreglerna (och utan att göra någon URL-kodning).

Bevilja behörigheter för att använda autentiseringsuppgifter

Databasanvändare som har åtkomst till en DATABASE SCOPED CREDENTIAL måste ha behörighet att använda den autentiseringsuppgiften.

Om du vill använda autentiseringsuppgifterna måste en databasanvändare ha REFERENCES behörighet för en specifik autentiseringsuppgift:

GRANT REFERENCES ON DATABASE SCOPED CREDENTIAL::[<CREDENTIAL_NAME>] TO [<PRINCIPAL>];

Remarks

Väntetyp

När sp_invoke_external_rest_endpoint väntar på att anropet till den anropade tjänsten ska slutföras rapporterar den en väntetyp HTTP_EXTERNAL_CONNECTION .

HTTPS och TLS

Endast slutpunkter som är konfigurerade att använda HTTPS med TLS-krypteringsprotokoll stöds.

HTTP-omdirigeringar

sp_invoke_external_rest_endpoint följer inte automatiskt någon HTTP-omdirigering som tas emot som ett svar från den anropade slutpunkten.

HTTP-huvuden

sp_invoke_external_rest_endpoint matar automatiskt in följande huvuden i HTTP-begäran:

• innehållstyp: inställd på application/json; charset=utf-8
• acceptera: inställd på application/json
• : ange <EDITION>/<PRODUCT VERSION> till exempel: SQL Azure/12.0.2000.8

Även om användaragenten alltid skrivs över av den lagrade proceduren kan innehållstypen och acceptera rubrikvärdena vara användardefinierade via parametern @headers . Endast medietypsdirektivet tillåts anges i innehållstypen och det går inte att ange teckenuppsättningen eller gränsdirektiven.

Nyttolast för begäran och svar som stöds medietyper

Följande är godkända värden för rubriken innehållstyp.

• application/json
• application/vnd.microsoft.*.json
• application/xml
• application/vnd.microsoft.*.xml
• application/vnd.microsoft.*+xml
• application/x-www-form-urlencoded
• text/*

För accepterar sidhuvud är följande godkända värden.

• application/json
• application/xml
• text/*

Mer information om texthuvudtyper finns i registret för texttyp på IANA.

Logik för antal återförsök

Om du anger parametern @retry_count kommer begäran att försöka igen när följande fel påträffas:

HTTP-fel

Metodtips

Använda en batchteknik

Om du måste skicka en uppsättning rader till en REST-slutpunkt, till exempel till en Azure-funktion eller till en händelsehubb, rekommenderar vi att du batchar raderna i ett enda JSON-dokument för att undvika HTTPS-anropskostnaderna för varje rad som skickas. Detta kan göras med hjälp av FOR JSON-instruktionen, till exempel:

-- create the payload
DECLARE @payload AS NVARCHAR (MAX);

SET @payload = (SELECT [object_id],
                       [name],
                       [column_id]
                FROM sys.columns
                FOR JSON AUTO);

-- invoke the REST endpoint
DECLARE @retcode AS INT, @response AS NVARCHAR (MAX);

EXECUTE
    @retcode = sp_invoke_external_rest_endpoint
    @url = '<REST_endpoint>',
    @payload = @payload,
    @response = @response OUTPUT;

-- return the result
SELECT @retcode,
       @response;

Examples

Här hittar du några exempel på hur du använder sp_invoke_external_rest_endpoint för att integrera med vanliga Azure-tjänster som Azure Functions eller Azure Event Hubs. Fler exempel för att integrera med andra tjänster finns på GitHub-.

A. Anropa en Azure-funktion med en HTTP-utlösarbindning utan autentisering

I följande exempel anropas en Azure-funktion med hjälp av en HTTP-utlösarbindning som tillåter anonym åtkomst.

DECLARE @ret AS INT, @response AS NVARCHAR (MAX);

EXECUTE
    @ret = sp_invoke_external_rest_endpoint
    @url = N'https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?key1=value1',
    @headers = N'{"header1":"value_a", "header2":"value2", "header1":"value_b"}',
    @payload = N'{"some":{"data":"here"}}',
    @response = @response OUTPUT;

SELECT @ret AS ReturnCode,
       @response AS Response;

B. Anropa en Azure-funktion med en HTTP-utlösarbindning med en auktoriseringsnyckel

I följande exempel anropas en Azure-funktion med en HTTP-utlösarbindning som konfigurerats för att kräva en auktoriseringsnyckel. Auktoriseringsnyckeln x-function-key skickas i huvudet enligt vad som krävs av Azure Functions. Mer information finns i Azure Functions – API-nyckelauktorisering.

CREATE DATABASE SCOPED CREDENTIAL [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>]
    WITH IDENTITY = 'HTTPEndpointHeaders', SECRET = '{"x-functions-key":"<your-function-key-here>"}';

DECLARE @ret AS INT, @response AS NVARCHAR (MAX);

EXECUTE
    @ret = sp_invoke_external_rest_endpoint
    @url = N'https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>?key1=value1',
    @headers = N'{"header1":"value_a", "header2":"value2", "header1":"value_b"}',
    @credential = [https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>],
    @payload = N'{"some":{"data":"here"}}',
    @response = @response OUTPUT;

SELECT @ret AS ReturnCode,
       @response AS Response;

C. Läsa innehållet i en fil från Azure Blob Storage med en SAS-token

I det här exemplet läss en fil från Azure Blob Storage med hjälp av en SAS-token för autentisering. Resultatet returneras i XML, så du måste använda rubriken "Accept":"application/xml".

DECLARE @ret AS INT, @response AS NVARCHAR (MAX);

EXECUTE
    @ret = sp_invoke_external_rest_endpoint
    @url = N'https://blobby.blob.core.windows.net/datafiles/my_favorite_blobs.txt?sp=r&st=2023-07-28T19:56:07Z&se=2023-07-29T03:56:07Z&spr=https&sv=2022-11-02&sr=b&sig=XXXXXX1234XXXXXX6789XXXXX',
    @headers = N'{"Accept":"application/xml"}',
    @method = 'GET',
    @response = @response OUTPUT;

SELECT @ret AS ReturnCode,
       @response AS Response;

D. Skicka ett meddelande till en händelsehubb med azure SQL Database Managed Identity

Det här exemplet visar hur du kan skicka meddelanden till Event Hubs med hjälp av Azure SQL Managed Identity. Kontrollera att du har konfigurerat systemhanterad identitet för den logiska Azure SQL Database-servern som är värd för databasen, till exempel:

az sql server update -g <resource-group> -n <azure-sql-server> --identity-type SystemAssigned

Därefter konfigurerar du Event Hubs så att Azure SQL Server hanterad identitet kan skicka meddelanden ("Azure Event Hubs Data Sender"-roll) till önskad händelsehubb. Mer information finns i Använda händelsehubbar med hanterade identiteter.

När detta är klart kan du använda identitetsnamnet Managed Identity när du definierar databasens begränsade autentiseringsuppgifter som används av sp_invoke_external_rest_endpoint. Som beskrivs i Autentisera ett program med Microsoft Entra-ID för att få åtkomst till Event Hubs-resurserär resursnamnet (eller ID:t) som ska användas när du använder Microsoft Entra-autentisering https://eventhubs.azure.net:

CREATE DATABASE SCOPED CREDENTIAL [https://<EVENT-HUBS-NAME>.servicebus.windows.net]
WITH IDENTITY = 'Managed Identity', SECRET = '{"resourceid": "https://eventhubs.azure.net"}';
GO

DECLARE @Id AS UNIQUEIDENTIFIER = NEWID();

DECLARE @payload AS NVARCHAR (MAX) = (SELECT *
    FROM (VALUES (@Id, 'John', 'Doe')) AS UserTable(UserId, FirstName, LastName)
    FOR JSON AUTO, WITHOUT_ARRAY_WRAPPER);

DECLARE @url AS NVARCHAR (4000) = 'https://<EVENT-HUBS-NAME>.servicebus.windows.net/from-sql/messages';

DECLARE @headers AS NVARCHAR (4000) = N'{"BrokerProperties": "'
    + STRING_ESCAPE('{"PartitionKey": "'
    + CAST (@Id AS NVARCHAR (36)) + '"}', 'json') + '"}';

DECLARE @ret AS INT, @response AS NVARCHAR (MAX);

EXECUTE
    @ret = sp_invoke_external_rest_endpoint
    @url = @url,
    @headers = @headers,
    @credential = [https://<EVENT-HUBS-NAME>.servicebus.windows.net],
    @payload = @payload,
    @response = @response OUTPUT;

SELECT @ret AS ReturnCode,
       @response AS Response;

E. Läsa och skriva en fil till Azure File Storage med autentiseringsuppgifter för Azure SQL Database

Det här exemplet skriver en fil till en Azure File Storage med en Azure SQL Database-omfångsautentisering för autentisering och returnerar sedan innehållet. Resultatet returneras i XML, så du måste använda rubriken "Accept":"application/xml".

Börja med att skapa en huvudnyckel för Azure SQL-databasen. Ersätt <password> med ett starkt lösenord.

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<password>';
GO

Skapa sedan autentiseringsuppgifterna för databasen med hjälp av SAS-token som tillhandahålls av Azure Blob Storage-kontot. Ersätt <token> med den angivna SAS-token.

CREATE DATABASE SCOPED CREDENTIAL [filestore]
WITH IDENTITY = 'SHARED ACCESS SIGNATURE', SECRET = '<token>';
GO

Skapa sedan filen och lägg till text i den med följande två instruktioner. Ersätt <domain> med lämplig sökväg.

DECLARE @payload AS NVARCHAR (MAX) = (SELECT *
    FROM (VALUES ('Hello from Azure SQL!', sysdatetime())) AS payload([message], [timestamp])
    FOR JSON AUTO, WITHOUT_ARRAY_WRAPPER);

DECLARE @response AS NVARCHAR (MAX);
DECLARE @url AS NVARCHAR (MAX);
DECLARE @headers AS NVARCHAR (1000);

DECLARE @len AS INT = len(@payload);

-- Create the file
SET @url = 'https://<domain>.file.core.windows.net/myfiles/test-me-from-azure-sql.json';
SET @headers = JSON_OBJECT('x-ms-type':'file', 'x-ms-content-length':CAST (@len AS VARCHAR (9)), 'Accept':'application/xml');

EXECUTE sp_invoke_external_rest_endpoint
    @url = @url,
    @method = 'PUT',
    @headers = @headers,
    @credential = [filestore],
    @response = @response OUTPUT;

SELECT CAST (@response AS XML);

-- Add text to the file
SET @headers = JSON_OBJECT('x-ms-range':'bytes=0-' + CAST (@len - 1 AS VARCHAR (9)), 'x-ms-write':'update', 'Accept':'application/xml');
SET @url = 'https://<domain>.file.core.windows.net/myfiles/test-me-from-azure-sql.json';
SET @url += '?comp=range';

EXECUTE sp_invoke_external_rest_endpoint
    @url = @url,
    @method = 'PUT',
    @headers = @headers,
    @payload = @payload,
    @credential = [filestore],
    @response = @response OUTPUT;

SELECT CAST (@response AS XML);
GO

Använd slutligen följande instruktion för att läsa filen. Ersätt <domain> med lämplig sökväg.

DECLARE @response AS NVARCHAR (MAX);

DECLARE @url AS NVARCHAR (MAX) = 'https://<domain>.file.core.windows.net/myfiles/test-me-from-azure-sql.json';

EXECUTE sp_invoke_external_rest_endpoint
    @url = @url,
    @headers = '{"Accept":"application/xml"}',
    @credential = [filestore],
    @method = 'GET',
    @response = @response OUTPUT;

SELECT CAST (@response AS XML);
GO

F. Anropa en Azure OpenAI med hanterad identitet

I följande exempel anropas en Azure OpenAI-modell med hanterade identiteter i Microsoft Entra för Azure SQL. Ersätt <my-azure-openai-endpoint> och <model-deployment-name> med din Azure OpenAI-slutpunkt respektive modellnamn och kontrollera att du har gett den hanterade identiteten rollen Cognitive Services OpenAI-användare i Azure OpenAI-tjänsten.

CREATE DATABASE SCOPED CREDENTIAL [https://<my-azure-openai-endpoint>.openai.azure.com]
    WITH IDENTITY = 'Managed Identity', SECRET = '{"resourceid":"https://cognitiveservices.azure.com"}';
GO

DECLARE @response AS NVARCHAR (MAX);

DECLARE @payload AS NVARCHAR (MAX) = JSON_OBJECT('input':'hello world');

EXECUTE sp_invoke_external_rest_endpoint
    @url = 'https://<my-azure-openai-endpoint>.openai.azure.com/openai/deployments/<model-deployment-name>/embeddings?api-version=2024-08-01-preview',
    @method = 'POST',
    @credential = [https://<my-azure-openai-endpoint>.openai.azure.com],
    @payload = @payload,
    @response = @response OUTPUT;

SELECT json_query(@response, '$.result.data[0].embedding'); -- Assuming the called model is an embedding model

Relaterat innehåll

• Resurshantering i Azure SQL Database
• sys.dm_resource_governor_resource_pools_history_ex
• sys.dm_resource_governor_workload_groups_history_ex
• sys.dm_user_db_resource_governance
• BEVILJA databasbehörigheter (Transact-SQL)
• SKAPA DATABASRELATERADE REFERENSER (Transact-SQL)
• API-hantering
• sp_invoke_external_rest_endpoint användningsexempel