Azure Functions Csatlakozás Azure SQL Database-be a Visual Studio Code használatával
Az Azure Functions segítségével anélkül csatlakoztathatja az Azure-szolgáltatásokat és más erőforrásokat a függvényekhez, hogy saját integrációs kódot kellene írnia. Ezek a kötések, amelyek mind a bemenetet, mind a kimenetet képviselik, a függvénydefinícióban deklarálódnak. A kötések adatai a függvények számára paraméterekként vannak megadva. Az eseményindító egy speciális típusú bemeneti kötés. Bár egy függvénynek csak egy eseményindítója van, több bemeneti és kimeneti kötéssel is rendelkezhet. További információ: Azure Functions-eseményindítók és kötések fogalmai.
Ez a cikk bemutatja, hogyan csatlakoztathatja az Azure SQL Database-t a Visual Studio Code-tal az előző rövid útmutatóban létrehozott függvényhez. A függvényhez hozzáadott kimeneti kötés adatokat ír a HTTP-kérésből az Azure SQL Database-ben lévő táblába.
Mielőtt hozzákezdene, el kell végeznie a következő rövid útmutatót: C#-függvény létrehozása az Azure-ban a Visual Studio Code használatával. Ha a cikk végén már megtisztította az erőforrásokat, végezze el újra a lépéseket a függvényalkalmazás és a kapcsolódó erőforrások Azure-beli újbóli létrehozásához.
Mielőtt hozzákezdene, el kell végeznie a következő rövid útmutatót: JavaScript-függvény létrehozása az Azure-ban a Visual Studio Code használatával. Ha a cikk végén már megtisztította az erőforrásokat, végezze el újra a lépéseket a függvényalkalmazás és a kapcsolódó erőforrások Azure-beli újbóli létrehozásához.
Mielőtt hozzákezdene, el kell végeznie a rövid útmutatót: Python-függvény létrehozása az Azure-ban a Visual Studio Code használatával. Ha a cikk végén már megtisztította az erőforrásokat, végezze el újra a lépéseket a függvényalkalmazás és a kapcsolódó erőforrások Azure-beli újbóli létrehozásához.
Az Azure Functions azure SQL-kötéseinek és eseményindítóinak beállításaival kapcsolatos további részletek az Azure Functions dokumentációjában találhatók.
Az Azure SQL Database-adatbázis létrehozása
Kövesse az Azure SQL Database létrehozási rövid útmutatót egy kiszolgáló nélküli Azure SQL Database létrehozásához. Az adatbázis üres lehet, vagy létrehozható az AdventureWorksLT mintaadatkészletből.
Amikor a rendszer kéri, adja meg az alábbi információkat:
Felszólítás Kiválasztás Erőforráscsoport Válassza ki azt az erőforráscsoportot, amelyben létrehozta a függvényalkalmazást az előző cikkben. Adatbázis neve Írja be mySampleDatabase
.Kiszolgáló neve Adjon meg egy egyedi nevet a kiszolgálónak. Nem tudunk pontos kiszolgálónevet megadni, mert a kiszolgálóneveknek globálisan egyedinek kell lenniük az Azure összes kiszolgálója számára, nem csak az előfizetésen belül. Hitelesítési módszer Kattintson az SQL Server-hitelesítés lehetőségre. Kiszolgáló rendszergazdájának felhasználóneve Írja be azureuser
.Jelszó Adjon meg egy jelszót, amely megfelel az összetettségi követelményeknek. A kiszolgáló elérésének engedélyezése az Azure-szolgáltatások és -erőforrások számára Válassza az Igen lehetőséget. A létrehozás befejezése után lépjen az Adatbázis panelre az Azure Portalon, és a Gépház alatt válassza ki a Csatlakozás ion sztringeket. Másolja a ADO.NET kapcsolati sztring SQL-hitelesítéshez. Illessze be a kapcsolati sztring egy ideiglenes dokumentumba későbbi használatra.
Hozzon létre egy táblát az adatok HTTP-kérésből való tárolásához. Az Azure Portalon lépjen az adatbázis paneljére, és válassza a Lekérdezésszerkesztő lehetőséget. Adja meg a következő lekérdezést egy tábla
dbo.ToDo
létrehozásához:CREATE TABLE dbo.ToDo ( [Id] UNIQUEIDENTIFIER PRIMARY KEY, [order] INT NULL, [title] NVARCHAR(200) NOT NULL, [url] NVARCHAR(200) NOT NULL, [completed] BIT NOT NULL );
Ellenőrizze, hogy az Azure-függvény hozzáfér-e az Azure SQL Database-hez a kiszolgáló tűzfalbeállításainak ellenőrzésével. Lépjen a kiszolgáló paneljére az Azure Portalon, majd a Biztonság területen válassza a Hálózatkezelés lehetőséget. Ellenőrizni kell az Azure-szolgáltatások és -erőforrások kiszolgálóhoz való hozzáférésének engedélyezésére vonatkozó kivételt.
A függvényalkalmazás beállításainak frissítése
Az előző rövid útmutatóban létrehozott egy függvényalkalmazást az Azure-ban. Ebben a cikkben úgy frissíti az alkalmazást, hogy adatokat írjon az imént létrehozott Azure SQL Database-be. Az Azure SQL Database-hez való csatlakozáshoz hozzá kell adnia annak kapcsolati sztring az alkalmazásbeállításokhoz. Ezután töltse le az új beállítást a local.settings.json fájlba, hogy helyi futtatáskor csatlakozzon az Azure SQL Database-hez.
Szerkessze a kapcsolati sztring a korábban létrehozott ideiglenes dokumentumban. Cserélje le a jelszó értékét
Password
az Azure SQL Database létrehozásakor használt jelszóra. Másolja ki a frissített kapcsolati sztring.Nyomja le a Ctrl/Cmd+shift+P billentyűkombinációt a parancskatalógus megnyitásához, majd keresse meg és futtassa a parancsot
Azure Functions: Add New Setting...
.Válassza ki az előző cikkben létrehozott függvényalkalmazást. Amikor a rendszer kéri, adja meg az alábbi információkat:
Felszólítás Kiválasztás Új alkalmazásbeállítás nevének megadása Gépelje be: SqlConnectionString
.Adja meg az "Sql Csatlakozás ionString" értékét Illessze be az imént másolt Azure SQL Database kapcsolati sztring. Ezzel létrehoz egy kapcsolat
SqlConnectionString
nevű alkalmazásbeállítást a függvényalkalmazásban az Azure-ban. Most letöltheti ezt a beállítást a local.settings.json fájlba.Nyomja le ismét a Ctrl/Cmd+shift+P billentyűkombinációt a parancskatalógus megnyitásához, majd keresse meg és futtassa a parancsot
Azure Functions: Download Remote Settings...
.Válassza ki az előző cikkben létrehozott függvényalkalmazást. Az Igen elemet választva felülírhatja a meglévő helyi beállításokat.
Ez letölti az összes beállítást az Azure-ból a helyi projektbe, beleértve az új kapcsolati sztring beállítást is. A letöltött beállítások többsége nem használható helyi futtatáskor.
Kötési bővítmények regisztrálása
Mivel Azure SQL kimeneti kötést használ, a projekt futtatása előtt telepítenie kell a megfelelő kötési bővítményt.
A HTTP- és időzítő-triggerek kivételével a kötések bővítménycsomagokként vannak implementálva. Futtassa a következő dotnet add package parancsot a terminálablakban az Azure SQL-bővítménycsomag projekthez való hozzáadásához.
dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Sql
A projekt bővítménykötegek használatára lett konfigurálva, amely automatikusan telepíti az előre meghatározott bővítménycsomagokat.
A bővítménycsomagok használata engedélyezve van a projekt gyökerénél található host.json fájlban, amely az alábbiak szerint jelenik meg:
{
"version": "2.0",
"logging": {
"applicationInsights": {
"samplingSettings": {
"isEnabled": true,
"excludedTypes": "Request"
}
}
},
"extensionBundle": {
"id": "Microsoft.Azure.Functions.ExtensionBundle",
"version": "[4.*, 5.0.0)"
},
"concurrency": {
"dynamicConcurrencyEnabled": true,
"snapshotPersistenceEnabled": true
}
}
:::
Most hozzáadhatja az Azure SQL kimeneti kötését a projekthez.
Kimeneti kötés hozzáadása
A Functionsben minden kötéstípushoz szükség van egy direction
, type
és egy egyedire name
a function.json fájlban. Az attribútumok definiálásának módja a függvényalkalmazás nyelvétől függ.
Nyissa meg a HttpExample.cs projektfájlt, és adja hozzá a következő ToDoItem
osztályt, amely meghatározza az adatbázisba írt objektumot:
namespace AzureSQL.ToDo
{
public class ToDoItem
{
public Guid Id { get; set; }
public int? order { get; set; }
public string title { get; set; }
public string url { get; set; }
public bool? completed { get; set; }
}
}
Egy C#-osztálytárprojektben a kötések a függvénymetódus kötési attribútumaiként vannak definiálva. A Functions által igényelt function.json fájl automatikusan létrejön ezen attribútumok alapján.
Nyissa meg a HttpExample.cs projektfájlt, és adja hozzá a következő kimeneti típusosztályt, amely meghatározza a függvényünk által a HTTP-válaszhoz és az SQL-kimenethez kiadandó kombinált objektumokat:
public static class OutputType
{
[SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
public ToDoItem ToDoItem { get; set; }
public HttpResponseData HttpResponse { get; set; }
}
Adjon hozzá egy felhasználói utasítást a Microsoft.Azure.Functions.Worker.Extensions.Sql
tárhoz a fájl tetején:
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
A kötési attribútumok közvetlenül a kódban vannak definiálva. Az Azure SQL kimeneti konfigurációja az Azure SQL kimeneti kötéséhez szükséges mezőket ismerteti.
Ebben a MultiResponse
forgatókönyvben kimeneti kötést extraOutputs
kell hozzáadnia a függvényhez.
app.http('HttpExample', {
methods: ['GET', 'POST'],
extraOutputs: [sendToSql],
handler: async (request, context) => {
Adja hozzá a következő tulajdonságokat a kötéskonfigurációhoz:
const sendToSql = output.sql({
commandText: 'dbo.ToDo',
connectionStringSetting: 'SqlConnectionString',
});
A kötési attribútumok közvetlenül a function_app.py fájlban vannak definiálva. A dekorátor használatával generic_output_binding
hozzáadhat egy Azure SQL-kimeneti kötést:
@app.generic_output_binding(arg_name="toDoItems", type="sql", CommandText="dbo.ToDo", ConnectionStringSetting="SqlConnectionString"
data_type=DataType.STRING)
Ebben a kódban arg_name
azonosítja a kódban hivatkozott kötési paramétert, azt jelzi, type
hogy a kimeneti kötés egy SQL kimeneti kötés, az a tábla, CommandText
amelybe a kötés ír, és ConnectionStringSetting
egy alkalmazásbeállítás neve, amely tartalmazza az Azure SQL-kapcsolati sztring. A kapcsolati sztring az Sql Csatlakozás ionString beállításban található a local.settings.json fájlban.
Kimeneti kötést használó kód hozzáadása
Cserélje le a meglévő futtatási metódust a következő kódra:
[Function("HttpExample")]
public static OutputType Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
FunctionContext executionContext)
{
var logger = executionContext.GetLogger("HttpExample");
logger.LogInformation("C# HTTP trigger function processed a request.");
var message = "Welcome to Azure Functions!";
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
response.WriteString(message);
// Return a response to both HTTP trigger and Azure SQL output binding.
return new OutputType()
{
ToDoItem = new ToDoItem
{
id = System.Guid.NewGuid().ToString(),
title = message,
completed = false,
url = ""
},
HttpResponse = response
};
}
Adjon hozzá egy kódot, amely a extraInputs
kimeneti kötési objektumot context
használja, hogy JSON-dokumentumot küldjön a nevesített kimeneti kötési függvénynek. sendToSql
Adja hozzá ezt a kódot az return
utasítás előtt.
const data = JSON.stringify([
{
// create a random ID
Id: crypto.randomUUID(),
title: name,
completed: false,
url: '',
},
]);
// Output to Database
context.extraOutputs.set(sendToSql, data);
A crypto
modul használatához adja hozzá a következő sort a fájl elejéhez:
const crypto = require("crypto");
Ezen a ponton a függvénynek a következőképpen kell kinéznie:
const { app, output } = require('@azure/functions');
const crypto = require('crypto');
const sendToSql = output.sql({
commandText: 'dbo.ToDo',
connectionStringSetting: 'SqlConnectionString',
});
app.http('HttpExample', {
methods: ['GET', 'POST'],
extraOutputs: [sendToSql],
handler: async (request, context) => {
try {
context.log(`Http function processed request for url "${request.url}"`);
const name = request.query.get('name') || (await request.text());
if (!name) {
return { status: 404, body: 'Missing required data' };
}
// Stringified array of objects to be inserted into the database
const data = JSON.stringify([
{
// create a random ID
Id: crypto.randomUUID(),
title: name,
completed: false,
url: '',
},
]);
// Output to Database
context.extraOutputs.set(sendToSql, data);
const responseMessage = name
? 'Hello, ' +
name +
'. This HTTP triggered function executed successfully.'
: 'This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.';
// Return to HTTP client
return { body: responseMessage };
} catch (error) {
context.log(`Error: ${error}`);
return { status: 500, body: 'Internal Server Error' };
}
},
});
Frissítse a HttpExample\function_app.py az alábbi kódnak megfelelően. Adja hozzá a paramétert toDoItems
a függvénydefinícióhoz és toDoItems.set()
az if name:
utasítás alatt:
import azure.functions as func
import logging
from azure.functions.decorators.core import DataType
app = func.FunctionApp()
@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
@app.generic_output_binding(arg_name="toDoItems", type="sql", CommandText="dbo.ToDo", ConnectionStringSetting="SqlConnectionString"
data_type=DataType.STRING)
def test_function(req: func.HttpRequest, toDoItems: func.Out[func.SqlRow]) -> func.HttpResponse:
logging.info('Python HTTP trigger function processed a request.')
name = req.params.get('name')
if not name:
try:
req_body = req.get_json()
except ValueError:
pass
else:
name = req_body.get('name')
if name:
toDoItems.set(func.SqlRow({"id": uuid.uuid4(), "title": name, "completed": false, url: ""}))
return func.HttpResponse(f"Hello {name}!")
else:
return func.HttpResponse(
"Please pass a name on the query string or in the request body",
status_code=400
)
Függvény helyi futtatása
A Visual Studio Code az Azure Functions Core-eszközökkel integrálva lehetővé teszi a projekt helyi fejlesztői számítógépen való futtatását, mielőtt közzétennénk az Azure-ban. Ha még nincs telepítve helyileg a Core Tools, a rendszer a projekt első futtatásakor kéri a telepítést.
A függvény meghívásához nyomja le az F5 billentyűt a függvényalkalmazás-projekt elindításához. A Terminál panelen a Core Tools kimenete látható. Az alkalmazás a Terminál panelen kezdődik. A HTTP által aktivált függvény URL-végpontja helyileg fut.
Ha még nincs telepítve a Core Tools, válassza a Telepítés lehetőséget a Core Tools telepítéséhez, amikor a rendszer erre kéri.
Ha problémákat tapasztal a Windows rendszeren való futtatással, győződjön meg arról, hogy a Visual Studio Code alapértelmezett terminálja nincs beállítva WSL Bash-ra.A Core Tools futtatásával lépjen az Azure: Functions területre. A Függvények területen bontsa ki a Helyi projektfüggvényeket>. Kattintson a jobb gombbal (Windows) vagy Ctrl billentyűkombinációra – kattintson a függvényre (macOS), és válassza a
HttpExample
Függvény végrehajtása parancsot....Az Enter kérelem törzsében nyomja le az Enter billentyűt, és küldjön egy kérésüzenetet a függvénynek.
Amikor a függvény helyileg fut, és választ ad vissza, a Rendszer értesítést küld a Visual Studio Code-ban. A függvény végrehajtásával kapcsolatos információk a Terminál panelen jelennek meg.
Nyomja le a Ctrl + C billentyűkombinációt a Core Tools leállításához és a hibakereső leválasztásához.
Függvény helyi futtatása
Az előző cikkhez hasonlóan nyomja le az F5 billentyűt a függvényalkalmazás-projekt és a Core Tools elindításához.
A Core Tools futtatásával lépjen az Azure: Functions területre. A Függvények területen bontsa ki a Helyi projektfüggvényeket>. Kattintson a jobb gombbal a függvényre (Ctrl billentyűt lenyomva tartva), és válassza a
HttpExample
Függvény végrehajtása parancsot....Az Enter kérelemtörzsben a kérelemüzenet törzsértéke jelenik
{ "name": "Azure" }
meg. Az Enter billentyűt lenyomva küldje el ezt a kérésüzenetet a függvénynek.A válasz visszaadása után nyomja le a Ctrl + C billentyűkombinációt a Core Tools leállításához.
Annak ellenőrzése, hogy az adatok meg lettek-e írva az adatbázisba
Az Azure Portalon lépjen vissza az Azure SQL Database-hez, és válassza a Lekérdezésszerkesztő lehetőséget.
Csatlakozás az adatbázishoz, és bontsa ki a Táblacsomópont a bal oldali Objektumkezelőben. Kattintson a jobb gombbal a
dbo.ToDo
táblára, és válassza a Felső 1000 sor kijelölése lehetőséget.Ellenőrizze, hogy az új adatokat a kimeneti kötés írta-e az adatbázisba.
A frissített alkalmazás ismételt üzembe helyezése és ellenőrzése
A Visual Studio Code-ban nyomja le az F1 billentyűt a parancskatalógus megnyitásához. A parancskatalógusban keresse meg és válassza ki a kívánt parancsot
Azure Functions: Deploy to function app...
.Válassza ki az első cikkben létrehozott függvényalkalmazást. Mivel újra üzembe helyezi a projektet ugyanabba az alkalmazásba, válassza az Üzembe helyezés lehetőséget a fájlok felülírására vonatkozó figyelmeztetés elvetéséhez.
Az üzembe helyezés befejezése után ismét használhatja az Execute Function Now... funkciót a függvény azure-beli aktiválásához.
Ellenőrizze ismét az Azure SQL Database-be írt adatokat, és ellenőrizze, hogy a kimeneti kötés ismét létrehoz-e új JSON-dokumentumot.
Az erőforrások eltávolítása
Az Azure-ban az erőforrások függvényalkalmazásokra, függvényekre, tárfiókokra és így tovább. Ezek erőforráscsoportokba vannak csoportosítva, és a csoport törlésével törölheti a csoport összes elemét.
E rövid útmutatók elvégzéséhez erőforrásokat hozott létre. Fiókjának állapotától és a szolgáltatási díjszabástól függően lehetséges, hogy az erőforrások használata díjköteles. Ha már nincs szüksége ezekre az erőforrásokra, a következőképpen törölheti őket:
A Visual Studio Code-ban nyomja le az F1 billentyűt a parancskatalógus megnyitásához. A parancskatalógusban keresse meg és válassza ki a kívánt parancsot
Azure: Open in portal
.Válassza ki a függvényalkalmazást, és nyomja le az Enter billentyűt. Megnyílik a függvényalkalmazás lapja az Azure Portalon.
Az Áttekintés lapon válassza az Erőforráscsoport melletti elnevezett hivatkozást.
Az Erőforráscsoport lapon tekintse át a belefoglalt erőforrások listáját, és ellenőrizze, hogy ezek-e törölni kívánt erőforrások.
Válassza az Erőforráscsoport törlése elemet, majd kövesse az utasításokat.
A törlés eltarthat néhány percig. Amint a művelet befejeződött, néhány másodpercre egy értesítés jelenik meg. Az értesítést úgy is megtekintheti, ha kiválasztja a harang ikont az oldal tetején.
Következő lépések
Frissítette a HTTP által aktivált függvényt, hogy adatokat írjon az Azure SQL Database-be. Most már többet tudhat meg a Functions Visual Studio Code-tal történő fejlesztéséről: