Függvény létrehozása Linux rendszerben egyéni tárolóval

  • Cikk
  • 27 perc alatt elolvasható

Ebben az oktatóanyagban a kódot egyéni Docker-tárolóként hozhatja létre és helyezheti üzembe linuxos alaprendszerkép használatával Azure Functions. Általában akkor használ egyéni rendszerképet, ha a függvények egy adott nyelvi verziót igényelnek, vagy a beépített rendszerkép által nem biztosított függőségekkel vagy konfigurációval rendelkeznek.

Azure Functions bármilyen nyelvet vagy futtatókörnyezetet támogat egyéni kezelők használatával. Bizonyos nyelvek, például az oktatóanyagban használt R programozási nyelv esetében a futtatókörnyezetet vagy több kódtárat függőségként kell telepítenie, amelyek egyéni tároló használatát igénylik.

A függvénykód egyéni Linux-tárolóban való üzembe helyezéséhez prémium szintű csomagra vagy dedikált (App Service) csomag üzemeltetésére van szükség. Az oktatóanyag elvégzése néhány amerikai dollárnyi költséget von maga után az Azure-fiókjában, amelyet minimálisra csökkentheti az erőforrások tisztításával , amikor végzett.

Az alapértelmezett Azure App Service tárolót is használhatja a Linuxon üzemeltetett első függvény létrehozása című szakaszban leírtak szerint. A Azure Functions támogatott alaprendszerképei az Azure Functions alaprendszerkép-adattárban találhatók.

Eben az oktatóanyagban az alábbiakkal fog megismerkedni:

  • Hozzon létre egy függvényalkalmazást és egy Dockerfile-t a Azure Functions Core Tools használatával.
  • Egyéni rendszerkép készítése a Docker használatával.
  • Egyéni rendszerkép közzététele egy tárolójegyzékben.
  • Támogató erőforrások létrehozása az Azure-ban a függvényalkalmazáshoz.
  • Függvényalkalmazás üzembe helyezése a Docker Hubból.
  • Alkalmazásbeállítások hozzáadása a függvényalkalmazáshoz.
  • Folyamatos üzembe helyezés engedélyezése.
  • Engedélyezze az SSH-kapcsolatokat a tárolóhoz.
  • Adjon hozzá egy Queue Storage kimeneti kötést.
  • Hozzon létre egy függvényalkalmazást és egy Dockerfile-t a Azure Functions Core Tools használatával.
  • Egyéni rendszerkép készítése a Docker használatával.
  • Egyéni rendszerkép közzététele egy tárolójegyzékben.
  • Támogató erőforrások létrehozása az Azure-ban a függvényalkalmazáshoz.
  • Függvényalkalmazás üzembe helyezése a Docker Hubból.
  • Alkalmazásbeállítások hozzáadása a függvényalkalmazáshoz.
  • Folyamatos üzembe helyezés engedélyezése.
  • Engedélyezze az SSH-kapcsolatokat a tárolóhoz.

Ezt az oktatóanyagot bármely Windows, macOS vagy Linux rendszerű számítógépen követheti.

A helyi környezet konfigurálása

A kezdés előtt a következő követelményekkel kell rendelkeznie:

  • Node.js, Active LTS és Maintenance LTS verziók (16.16.0 és 14.20.0 ajánlott).
  • Fejlesztői eszközök a használt nyelvhez. Ez az oktatóanyag az R programozási nyelvet használja példaként.

Ha nem rendelkezik Azure-előfizetéssel, a kezdés előtt hozzon létre egy ingyenes Azure-fiókot .

Docker- és Docker-azonosítót is be kell szereznie:

Virtuális környezet létrehozása és aktiválása

Egy megfelelő mappában futtassa az alábbi parancsokat egy virtuális környezet létrehozásához és aktiválásához..venv Győződjön meg arról, hogy a Azure Functions által támogatott Python 3.8-at, 3.7-et vagy 3.6-ot használ.

python -m venv .venv

source .venv/bin/activate

Ha a Python nem telepítette a venv-csomagot a Linux-disztribúcióra, futtassa a következő parancsot:

sudo apt-get install python3-venv

Az összes további parancsot ebben az aktivált virtuális környezetben futtatja.

A helyi függvényprojekt létrehozása és tesztelése

Egy terminálban vagy parancssorban futtassa a következő parancsot a választott nyelvhez egy függvényalkalmazás-projekt létrehozásához az aktuális mappában:

func init --worker-runtime dotnet --docker

func init --worker-runtime node --language javascript --docker

func init --worker-runtime powershell --docker

func init --worker-runtime python --docker

func init --worker-runtime node --language typescript --docker

Egy üres mappában futtassa a következő parancsot a Functions-projekt Maven-archetípusból való létrehozásához:

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DjavaVersion=8 -Ddocker

A -DjavaVersion paraméter tájékoztatja a Functions-futtatókörnyezetet, hogy melyik Java-verziót használja. Használja a -DjavaVersion=11 kapcsolót, ha a függvényeket Java 11-en szeretné futtatni. Ha nem adja meg -DjavaVersion, a Maven alapértelmezés szerint Java 8.. További információ: Java-verziók.

Fontos

A JAVA_HOME cikk elvégzéséhez a környezeti változót a JDK megfelelő verziójának telepítési helyére kell állítani.

A Maven kéri a projekt üzembe helyezése során történő létrehozásának befejezéséhez szükséges értékeket. Kövesse az utasításokat, és adja meg a következő információkat:

Adatkérés Érték Leírás
csoportazonosító com.fabrikam Egy érték, amely egyedileg azonosítja a projektet az összes projektben a Java csomagelnevezési szabályainak megfelelően.
artifactId fabrikam-functions Egy érték, amely a jar neve, verziószám nélkül.
verzió 1.0-SNAPSHOT Válassza ki az alapértelmezett értéket.
csomag com.fabrikam.functions Egy érték, amely a létrehozott függvénykód Java-csomagja. Használja az alapértelmezettet.

A megerősítéshez írja be Y vagy nyomja le az Enter billentyűt.

A Maven egy artifactId nevű új mappában hozza létre a projektfájlokat, amely ebben a példában az fabrikam-functions.

func init --worker-runtime custom --docker

A --docker beállítás létrehoz egy Dockerfile-t a projekthez, amely egy megfelelő egyéni tárolót határoz meg a Azure Functions és a kiválasztott futtatókörnyezet használatához.

Lépjen a projektmappába:

cd fabrikam-functions

Nincs szükség a Dockerfile módosítására.

A következő paranccsal adjon hozzá egy függvényt a projekthez, ahol az --name argumentum a függvény egyedi neve, az --template argumentum pedig a függvény eseményindítóját határozza meg. func new C#-kódfájlt hoz létre a projektben.

func new --name HttpExample --template "HTTP trigger" --authlevel anonymous

A következő paranccsal adjon hozzá egy függvényt a projekthez, ahol az --name argumentum a függvény egyedi neve, az --template argumentum pedig a függvény eseményindítóját határozza meg. func new A létrehoz egy almappát, amely megfelel a function.json nevű konfigurációs fájlt tartalmazó függvénynévnek.

func new --name HttpExample --template "HTTP trigger" --authlevel anonymous

Egy szövegszerkesztőben hozzon létre egy fájlt a projektmappában, amelyet kezelőnek nevezünk. R. Adja hozzá a következő kódot tartalomként:

library(httpuv)

PORTEnv <- Sys.getenv("FUNCTIONS_CUSTOMHANDLER_PORT")
PORT <- strtoi(PORTEnv , base = 0L)

http_not_found <- list(
  status=404,
  body='404 Not Found'
)

http_method_not_allowed <- list(
  status=405,
  body='405 Method Not Allowed'
)

hello_handler <- list(
  GET = function (request) {
    list(body=paste(
      "Hello,",
      if(substr(request$QUERY_STRING,1,6)=="?name=") 
        substr(request$QUERY_STRING,7,40) else "World",
      sep=" "))
  }
)

routes <- list(
  '/api/HttpExample' = hello_handler
)

router <- function (routes, request) {
  if (!request$PATH_INFO %in% names(routes)) {
    return(http_not_found)
  }
  path_handler <- routes[[request$PATH_INFO]]

  if (!request$REQUEST_METHOD %in% names(path_handler)) {
    return(http_method_not_allowed)
  }
  method_handler <- path_handler[[request$REQUEST_METHOD]]

  return(method_handler(request))
}

app <- list(
  call = function (request) {
    response <- router(routes, request)
    if (!'status' %in% names(response)) {
      response$status <- 200
    }
    if (!'headers' %in% names(response)) {
      response$headers <- list()
    }
    if (!'Content-Type' %in% names(response$headers)) {
      response$headers[['Content-Type']] <- 'text/plain'
    }

    return(response)
  }
)

cat(paste0("Server listening on :", PORT, "...\n"))
runServer("0.0.0.0", PORT, app)

A host.json fájlban módosítsa a szakaszt customHandler az egyéni kezelő indítási parancsának konfigurálásához.

"customHandler": {
  "description": {
      "defaultExecutablePath": "Rscript",
      "arguments": [
      "handler.R"
    ]
  },
  "enableForwardingHttpRequest": true
}

A függvény helyi teszteléséhez indítsa el a helyi Azure Functions futtatókörnyezeti gazdagépet a projektmappa gyökerében.

func start  

func start  

npm install
npm start

mvn clean package  
mvn azure-functions:run

R -e "install.packages('httpuv', repos='http://cran.rstudio.com/')"
func start

Miután a végpont megjelenik HttpExample a kimenetben, lépjen a következőre http://localhost:7071/api/HttpExample?name=Functions: . A böngészőnek meg kell jelenítenie egy "hello" üzenetet, amely visszaköszön Functionsa lekérdezési paraméterhez megadott értékre name .

Nyomja le a CtrlCbillentyűkombinációt+ a gazdagép leállításához.

A tárolórendszerkép létrehozása és helyi tesztelése

(Nem kötelező) Vizsgálja meg a Dockerfile-t a projektmappa gyökerében. A Dockerfile leírja a függvényalkalmazás Linuxon való futtatásához szükséges környezetet. Az Azure Functions támogatott alaprendszerképeinek teljes listája az Azure Functions alaprendszerkép oldalán található.

Vizsgálja meg a Dockerfile-t a projektmappa gyökerében. A Dockerfile leírja a függvényalkalmazás Linuxon való futtatásához szükséges környezetet. Az egyéni kezelőalkalmazások a rendszerképet mcr.microsoft.com/azure-functions/dotnet:3.0-appservice használják alapként.

Módosítsa a Dockerfile-t az R telepítéséhez. Cserélje le a Dockerfile tartalmát a következő kódra:

FROM mcr.microsoft.com/azure-functions/dotnet:3.0-appservice 
ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
    AzureFunctionsJobHost__Logging__Console__IsEnabled=true

RUN apt update && \
    apt install -y r-base && \
    R -e "install.packages('httpuv', repos='http://cran.rstudio.com/')"

COPY . /home/site/wwwroot

A gyökérprojekt mappájában futtassa a docker build parancsot, adjon meg egy nevet azurefunctionsimagemint , és címkézze meg.v1.0.0 A <DOCKER_ID> helyére a Docker Hub-fiók azonosítóját írja. Ez a parancs létrehozza a tároló Docker-rendszerképét.

docker build --tag <DOCKER_ID>/azurefunctionsimage:v1.0.0 .

Amikor a parancs befejeződik, helyileg futtathatja az új tárolót.

A build teszteléséhez futtassa a lemezképet egy helyi tárolóban a Docker-futtatási paranccsal, cserélje le <docker_id> ismét a Docker Hub fiókazonosítóját, és adja hozzá a portok argumentumát a következőként-p 8080:80:

docker run -p 8080:80 -it <docker_id>/azurefunctionsimage:v1.0.0

Miután a rendszerkép megkezdődik a helyi tárolóban, keresse meg http://localhost:8080/api/HttpExample?name=Functionsa következőt, amelynek a "hello" üzenetet kell megjelenítenie, mint korábban. Mivel a létrehozott HTTP-aktivált függvény névtelen hitelesítést használ, a tárolóban futó függvényt anélkül hívhatja meg, hogy hozzáférési kulcsot kellene beszereznie. További információ: engedélyezési kulcsok.

Miután a rendszerkép megkezdődik a helyi tárolóban, keresse meg http://localhost:8080/api/HttpExample?name=Functionsa következőt, amelynek a "hello" üzenetet kell megjelenítenie, mint korábban. Mivel a létrehozott HTTP-aktivált függvény névtelen hitelesítést használ, a tárolóban futó függvényt anélkül hívhatja meg, hogy hozzáférési kulcsot kellene beszereznie. További információ: engedélyezési kulcsok.

Miután ellenőrizte a függvényalkalmazást a tárolóban, nyomja le a CtrlCbillentyűkombinációt+ a docker leállításához.

A kép leküldése Docker Hub

Docker Hub egy tárolóregisztrációs adatbázis, amely lemezképeket tárol, és lemezkép- és tárolószolgáltatásokat nyújt. Ha meg szeretné osztani a rendszerképet, amely magában foglalja az Azure-ban való üzembe helyezést, le kell küldenie egy regisztrációs adatbázisba.

  1. Ha még nem jelentkezett be a Dockerbe, tegye ezt a Docker bejelentkezési parancsával, és cserélje le <docker_id> Docker Hub fiókazonosítóját. Ez a parancssor kéri a felhasználónevét és a jelszavát. A "Bejelentkezés sikeres" üzenet megerősíti, hogy bejelentkezett.

    docker login

  2. Miután bejelentkezett, küldje le a rendszerképet Docker Hub a Docker leküldéses parancsával, majd cserélje le ismét a <docker_id> Docker Hub fiókazonosítójára.

    docker push <docker_id>/azurefunctionsimage:v1.0.0

  3. A hálózati sebességtől függően a rendszerkép első leküldése eltarthat néhány percig (a későbbi módosítások leküldése sokkal gyorsabb). Amíg várakozik, továbbléphet a következő szakaszra, és azure-erőforrásokat hozhat létre egy másik terminálban.

Támogató Azure-erőforrások létrehozása a függvényhez

Mielőtt üzembe helyezheti a függvénykódot az Azure-ban, létre kell hoznia három erőforrást:

  • Egy erőforráscsoport, amely a kapcsolódó erőforrások logikai tárolója.
  • Egy Storage-fiók, amely a függvények állapotának és egyéb információinak fenntartására szolgál.
  • Egy függvényalkalmazás, amely biztosítja a függvénykód végrehajtásához szükséges környezetet. A függvényalkalmazások leképezik a helyi függvényprojektet, és lehetővé teszi a függvények logikai egységként való csoportosítását az erőforrások egyszerűbb kezelése, üzembe helyezése és megosztása érdekében.

Ezeket az elemeket az alábbi parancsokkal hozhatja létre. Az Azure CLI és a PowerShell is támogatott.

  1. Ha még nem tette meg, jelentkezzen be az Azure-ba.

    az login

    Az az login parancs bejelentkezteti Az Azure-fiókjába.

  2. Hozzon létre egy erőforráscsoportot AzureFunctionsContainers-rg a kiválasztott régióban.

    az group create --name AzureFunctionsContainers-rg --location <REGION>

    Az az group create parancs létrehoz egy erőforráscsoportot. A fenti parancsban cserélje le <REGION> az Önhöz közeli régióra az az account list-locations parancs által visszaadott elérhető régiókódot használva.

  3. Hozzon létre egy általános célú tárfiókot az erőforráscsoportban és a régióban.

    az storage account create --name <STORAGE_NAME> --location <REGION> --resource-group AzureFunctionsContainers-rg --sku Standard_LRS

    Az az storage account create parancs létrehozza a tárfiókot.

    Az előző példában cserélje le <STORAGE_NAME> az Ön számára megfelelő és az Azure Storage-ban egyedi nevet. A tárolónevek csak 3–24 karakterből álló számokat és kisbetűket tartalmazhatnak. Standard_LRS A a Functions által támogatott általános célú fiókot határoz meg.

  4. A paranccsal hozzon létre egy Prémium csomagot Azure Functions myPremiumPlan az Elastic Premium 1 tarifacsomagban (--sku EP1), az Önben <REGION>és egy Linux-tárolóban (--is-linux).

    az functionapp plan create --resource-group AzureFunctionsContainers-rg --name myPremiumPlan --location <REGION> --number-of-workers 1 --sku EP1 --is-linux

    Itt a Prémium csomagot használjuk, amely igény szerint méretezhető. További információ az üzemeltetésről: Azure Functions üzemeltetési csomagok összehasonlítása. A költségek kiszámításáról további információt a Functions díjszabási oldalán talál.

    A parancs egy társított Azure-alkalmazás Insights-példányt is kiépít ugyanabban az erőforráscsoportban, amellyel figyelheti a függvényalkalmazást, és megtekintheti a naplókat. További információ: Monitorozási Azure Functions. A példány nem jár költségekkel, amíg nem aktiválja.

Függvényalkalmazás létrehozása és konfigurálása az Azure-ban a rendszerképpel

Az Azure-beli függvényalkalmazás felügyeli a függvények végrehajtását az üzemeltetési csomagban. Ebben a szakaszban az előző szakasz Azure-erőforrásait használva hozzon létre egy függvényalkalmazást egy Docker Hub rendszerképéből, és konfigurálja azt egy kapcsolati sztring az Azure Storage-ba.

  1. Hozzon létre egy függvényalkalmazást a következő paranccsal:

    az functionapp create --name <APP_NAME> --storage-account <STORAGE_NAME> --resource-group AzureFunctionsContainers-rg --plan myPremiumPlan --deployment-container-image-name <DOCKER_ID>/azurefunctionsimage:v1.0.0

    Az az functionapp create parancsban a deployment-container-image-name paraméter határozza meg a függvényalkalmazáshoz használni kívánt rendszerképet. Az az functionapp config container show paranccsal megtekintheti az üzembe helyezéshez használt lemezkép adatait. Az az functionapp config container set parancsot is használhatja egy másik rendszerképből történő üzembe helyezéshez.

    Megjegyzés

    Ha egyéni tárolóregisztrációs adatbázist használ, akkor a deployment-container-image-name paraméter a beállításjegyzék URL-címére fog hivatkozni.

    Ebben a példában cserélje le <STORAGE_NAME> a tárfiók előző szakaszában használt névre. Emellett cserélje le <APP_NAME> az Ön számára megfelelő globálisan egyedi nevet, valamint <DOCKER_ID> a Docker Hub fiókazonosítóját. Amikor egyéni tárolóregisztrációs adatbázisból telepíti az üzembe helyezést, a deployment-container-image-name paraméterrel jelezze a beállításjegyzék URL-címét.

    Tipp

    A host.jsonfájlban található beállítássalDisableColor megakadályozhatja, hogy az ANSI-vezérlőkarakterek a tárolónaplókba legyenek írva.

  2. Az alábbi paranccsal kérje le a létrehozott tárfiók kapcsolati sztring:

    az storage account show-connection-string --resource-group AzureFunctionsContainers-rg --name <STORAGE_NAME> --query connectionString --output tsv

    A tárfiók kapcsolati sztring az az storage account show-connection-string paranccsal adja vissza.

    Cserélje le <STORAGE_NAME> a korábban létrehozott tárfiók nevére.

  3. A következő paranccsal adja hozzá a beállítást a függvényalkalmazáshoz:

    az functionapp config appsettings set --name <APP_NAME> --resource-group AzureFunctionsContainers-rg --settings AzureWebJobsStorage=<CONNECTION_STRING>

    Az az functionapp config appsettings set parancs létrehozza a beállítást.

    Ebben a parancsban cserélje le <APP_NAME> a függvényalkalmazás nevére és <CONNECTION_STRING> az előző lépés kapcsolati sztring. A kapcsolatnak egy hosszú kódolású sztringnek kell lennie, amely a következővel DefaultEndpointProtocol=kezdődik: .

  4. A függvény most már használhatja ezt a kapcsolati sztring a tárfiók eléréséhez.

Megjegyzés

Ha az egyéni rendszerképet egy privát tárolóregisztrációs adatbázisban teszi közzé, a kapcsolati sztring helyett a Dockerfile környezeti változóit kell használnia. További információ: ENV utasítás. A változókat és DOCKER_REGISTRY_SERVER_PASSWORD a DOCKER_REGISTRY_SERVER_USERNAME változókat is meg kell adnia. Az értékek használatához újra kell építenie a rendszerképet, le kell küldenie a rendszerképet a beállításjegyzékbe, majd újra kell indítania a függvényalkalmazást az Azure-ban.

A függvények ellenőrzése az Azure-ban

Az Azure-ban a függvényalkalmazásban üzembe helyezett rendszerkép használatával mostantól a HTTP-kérésekkel ugyanúgy hívhatja meg a függvényt, mint korábban. A böngészőben keresse meg a következő URL-címet:

https://<APP_NAME>.azurewebsites.net/api/HttpExample?name=Functions

https://<APP_NAME>.azurewebsites.net/api/HttpExample?name=Functions

Cserélje le <APP_NAME> a függvényalkalmazás nevére. Ha erre az URL-címre lép, a böngészőnek hasonló kimenetet kell megjelenítenie, mint amikor helyileg futtatta a függvényt.

Folyamatos üzembe helyezés engedélyezése az Azure-ban

Engedélyezheti Azure Functions számára, hogy automatikusan frissítse a rendszerkép központi telepítését, amikor frissíti a lemezképet a beállításjegyzékben.

  1. A következő paranccsal engedélyezheti a folyamatos üzembe helyezést, és lekérheti a webhook URL-címét:

    az functionapp deployment container config --enable-cd --query CI_CD_URL --output tsv --name <APP_NAME> --resource-group AzureFunctionsContainers-rg

    Az az functionapp deployment container config parancs lehetővé teszi a folyamatos üzembe helyezést, és visszaadja az üzembehelyezési webhook URL-címét. Ezt az URL-címet később bármikor lekérheti az az functionapp deployment container show-cd-url paranccsal.

    A korábbiakhoz hasonlóan cserélje le <APP_NAME> a függvényalkalmazás nevét.

  2. Másolja az üzembehelyezési webhook URL-címét a vágólapra.

  3. Nyissa meg Docker Hub, jelentkezzen be, és válassza az Adattárak lehetőséget a navigációs sávon. Keresse meg és jelölje ki a képet, válassza a Webhookok lapot, adjon meg egy webhooknevet, illessze be az URL-címet a Webhook URL-címbe, majd válassza a Létrehozás lehetőséget.

    Képernyőkép a webhook hozzáadásáról a Docker Hub ablakban.

  4. A webhook beállítása után Azure Functions újra üzembe helyezi a rendszerképet, amikor frissíti Docker Hub.

SSH-kapcsolatok engedélyezése

Az SSH lehetővé teszi a tároló és az ügyfél közötti biztonságos kommunikációt. Ha az SSH engedélyezve van, App Service Speciális eszközök (Kudu) használatával csatlakozhat a tárolóhoz. Az SSH-val való egyszerű csatlakozás érdekében Azure Functions biztosít egy alaprendszerképet, amelyen már engedélyezve van az SSH. Csak szerkesztenie kell a Dockerfile-t, majd újra kell építenie és újra üzembe kell helyeznie a lemezképet. Ezután a Speciális eszközök (Kudu) segítségével csatlakozhat a tárolóhoz.

  1. A Dockerfile-ban fűzze hozzá a sztringet -appservice az alaprendszerképhez az FROM utasításban.

    FROM mcr.microsoft.com/azure-functions/dotnet:3.0-appservice

    FROM mcr.microsoft.com/azure-functions/node:2.0-appservice

    FROM mcr.microsoft.com/azure-functions/powershell:2.0-appservice

    FROM mcr.microsoft.com/azure-functions/python:2.0-python3.7-appservice

    FROM mcr.microsoft.com/azure-functions/node:2.0-appservice

  2. A parancs ismételt használatával újraépítheti a docker build rendszerképet, és cserélje le a <docker_id> Docker Hub fiókazonosítójára.

    docker build --tag <docker_id>/azurefunctionsimage:v1.0.0 .

  3. A frissített rendszerkép leküldése Docker Hub, ami jelentősen kevesebb időt vesz igénybe, mint az első leküldés. Most csak a kép frissített szegmenseit kell feltölteni.

    docker push <docker_id>/azurefunctionsimage:v1.0.0

  4. Azure Functions automatikusan újra üzembe helyezi a rendszerképet a függvényalkalmazásban; a folyamat kevesebb mint egy perc alatt lezajlott.

  5. Egy böngészőben nyissa meg https://<app_name>.scm.azurewebsites.net/ és cserélje le <app_name> az egyedi nevét. Ez az URL-cím a függvényalkalmazás-tároló Speciális eszközök (Kudu) végpontja.

  6. Jelentkezzen be az Azure-fiókjába, majd válassza ki az SSH-t a tárolóval való kapcsolat létrehozásához. A csatlakozás eltarthat néhány percig, ha az Azure továbbra is frissíti a tárolórendszerképet.

  7. Miután létrejött a kapcsolat a tárolóval, futtassa a top parancsot az aktuálisan futó folyamatok megtekintéséhez.

    Képernyőkép egy SSH-munkamenetben futó Linux felső parancsról.

Írás az Azure Queue Storage-ba

Azure Functions lehetővé teszi a függvények más Azure-szolgáltatásokhoz és -erőforrásokhoz való csatlakoztatását anélkül, hogy saját integrációs kódot kellene írnia. Ezek a kötések, amelyek bemenetet és kimenetet is képviselnek, a függvénydefinícióban vannak deklarálva. A kötések adatai a függvények számára paraméterekként vannak megadva. Az eseményindítók speciális típusú bemeneti kötések. Bár egy függvény csak egy eseményindítóval rendelkezik, több bemeneti és kimeneti kötéssel is rendelkezhet. További információ: Azure Functions triggerek és kötések fogalmai.

Ez a szakasz bemutatja, hogyan integrálhatja a függvényt egy Azure Queue Storage-tárolóval. A függvényhez hozzáadott kimeneti kötés adatokat ír egy HTTP-kérésből egy üzenetsorba.

Az Azure Storage kapcsolati sztring lekérése

Korábban létrehozott egy Azure Storage-fiókot a függvényalkalmazás használatához. A fiók kapcsolati sztring biztonságosan tárolva van az Azure-beli alkalmazásbeállításokban. Ha letölti a beállítást a local.settings.json fájlba, a kapcsolat segítségével írhat egy storage-üzenetsorba ugyanabban a fiókban a függvény helyi futtatásakor.

  1. A projekt gyökerében futtassa a következő parancsot, és cserélje le <APP_NAME> az előző lépésben szereplő függvényalkalmazás nevére. Ez a parancs felülírja a fájl meglévő értékeit.

    func azure functionapp fetch-app-settings <APP_NAME>

  2. Nyissa meg a local.settings.json fájlt, és keresse meg a Storage-fiók kapcsolati sztring nevű AzureWebJobsStorageértéket. A cikk más szakaszaiban a nevet AzureWebJobsStorage és a kapcsolati sztring fogja használni.

Fontos

Mivel a local.settings.json fájl az Azure-ból letöltött titkos kódokat tartalmaz, mindig zárja ki ezt a fájlt a verziókövetésből. A helyi függvényprojekttel létrehozott .gitignore fájl alapértelmezés szerint kizárja a fájlt.

Kötési bővítmények regisztrálása

A HTTP- és időzítő-triggerek kivételével a kötések bővítménycsomagként vannak implementálva. Futtassa a következő dotnet add package parancsot a terminálablakban a Storage bővítménycsomag projekthez való hozzáadásához.

dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage

Most hozzáadhatja a tárkimeneti kötést a projekthez.

Kimeneti kötés definíciójának hozzáadása a függvényhez

Bár egy függvénynek csak egy eseményindítója lehet, több bemeneti és kimeneti kötéssel is rendelkezhet, így egyéni integrációs kód írása nélkül csatlakozhat más Azure-szolgáltatásokhoz és -erőforrásokhoz.

Ezeket a kötéseket a függvénymappában található function.json fájlban deklarálja. Az előző rövid útmutatóban a HttpExample mappában lévő function.json fájl két kötést tartalmaz a bindings gyűjteményben:

"bindings": [
    {
        "authLevel": "function",
        "type": "httpTrigger",
        "direction": "in",
        "name": "req",
        "methods": [
            "get",
            "post"
        ]
    },
    {
        "type": "http",
        "direction": "out",
        "name": "res"
    }
]

"scriptFile": "__init__.py",
"bindings": [
    {
        "authLevel": "function",
        "type": "httpTrigger",
        "direction": "in",
        "name": "req",
        "methods": [
            "get",
            "post"
        ]
    },
    {
        "type": "http",
        "direction": "out",
        "name": "$return"
    }

"bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "Request",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "Response"
  }
]

Minden kötésnek van legalább egy típusa, egy iránya és egy neve. A fenti példában az első kötés típusa httpTrigger az irány in. in Az irányhoz egy bemeneti paraméter nevét adja meg, name amelyet az eseményindító meghívásakor küld a függvénynek.

A gyűjtemény második kötésének neve res. Ez http a kötés egy kimeneti kötés (out), amely a HTTP-válasz megírására szolgál.

Ha ebből a függvényből szeretne írni egy Azure Storage-üzenetsorba, adjon hozzá egy out névvel rendelkező kötést queue , msgaz alábbi kódban látható módon:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

A gyűjtemény második kötése olyan típusúhttp, amelynek az iránya outvan– ebben az esetben a speciális $returnname érték azt jelzi, hogy ez a kötés a függvény visszatérési értékét használja a bemeneti paraméter megadása helyett.

Ha ebből a függvényből szeretne írni egy Azure Storage-üzenetsorba, adjon hozzá egy out névvel rendelkező kötést queue , msgaz alábbi kódban látható módon:

"bindings": [
  {
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "$return"
  },
  {
    "type": "queue",
    "direction": "out",
    "name": "msg",
    "queueName": "outqueue",
    "connection": "AzureWebJobsStorage"
  }
]

A gyűjtemény második kötésének neve res. Ez http a kötés egy kimeneti kötés (out), amely a HTTP-válasz megírására szolgál.

Ha ebből a függvényből szeretne írni egy Azure Storage-üzenetsorba, adjon hozzá egy out névvel rendelkező kötést queue , msgaz alábbi kódban látható módon:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Ebben az esetben msg a függvény kimeneti argumentumként van megadva. Típus esetén queue meg kell adnia az üzenetsor queueName nevét is, és meg kell adnia az Azure Storage-kapcsolat nevét (a local.settings.json fájlból) a fájlban connection.

Egy C#-projektben a kötések a függvénymetódus kötési attribútumaiként vannak definiálva. A meghatározott definíciók attól függenek, hogy az alkalmazás folyamatban (C#-osztálytár) vagy elkülönített folyamatban fut-e.

Nyissa meg a HttpExample.cs projektfájlt, és adja hozzá a következő paramétert a Run metódusdefinícióhoz:

[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg,

A msg paraméter egy ICollector<T> típus, amely egy kimeneti kötésbe írt üzenetek gyűjteményét jelöli a függvény befejezésekor. Ebben az esetben a kimenet egy .outqueue Ez StorageAccountAttribute beállítja a tárfiók kapcsolati sztring. Ez az attribútum azt a beállítást jelzi, amely tartalmazza a tárfiók kapcsolati sztring, és az osztály, a metódus vagy a paraméter szintjén alkalmazható. Ebben az esetben kihagyhatja StorageAccountAttribute , mert már használja az alapértelmezett tárfiókot.

A Run metódus definíciójának most a következő kódhoz kell hasonlítania:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

Egy Java-projektben a kötések kötési széljegyzetekként vannak definiálva a függvénymetódusban. A function.json fájl ezután automatikusan létrejön ezen széljegyzetek alapján.

Keresse meg a függvénykód helyét az src/main/java területen, nyissa meg a Függvény.java projektfájlt, és adja hozzá a következő paramétert a run metódusdefinícióhoz:

@QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") OutputBinding<String> msg

A msg paraméter egy OutputBinding<T> olyan típus, amely sztringek gyűjteményét jelöli. Ezek a sztringek üzenetként lesznek megírva egy kimeneti kötésbe a függvény befejezésekor. Ebben az esetben a kimenet egy .outqueue A Storage-fiók kapcsolati sztring a connection metódus állítja be. A kapcsolati sztring átadása helyett a Tárfiók kapcsolati sztring tartalmazó alkalmazásbeállítást adja át.

A run metódusdefiníciónak most az alábbi példához hasonlóan kell kinéznie:

@FunctionName("HttpTrigger-Java")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION)  
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", connection = "AzureWebJobsStorage") 
        OutputBinding<String> msg, final ExecutionContext context) {
    ...
}

Kód hozzáadása a kimeneti kötés használatához

Az üzenetsor-kötés definiálása után frissítheti a függvényt, hogy üzeneteket írjon az üzenetsorba a kötési paraméterrel.

Frissítse a HttpExample\__init__.py az alábbi kódnak megfelelően, adja hozzá a msg paramétert a függvénydefinícióhoz és msg.set(name) az if name: utasítás alá:

import logging

import azure.functions as func


def main(req: func.HttpRequest, msg: func.Out[func.QueueMessage]) -> str:

    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:
        msg.set(name)
        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
        )

A msg paraméter a azure.functions.Out class. A set metódus sztringüzenetet ír az üzenetsorba. Ebben az esetben ez az URL-lekérdezési sztringben a függvénynek átadott név.

Adjon hozzá egy kódot, amely a msg kimeneti kötési objektumot context.bindings használja egy üzenetsor-üzenet létrehozásához. Adja hozzá ezt a kódot az context.res utasítás előtt.

// Add a message to the Storage queue,
// which is the name passed to the function.
context.bindings.msg = (req.query.name || req.body.name);

Ekkor a függvénynek a következőképpen kell kinéznie:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');

    if (req.query.name || (req.body && req.body.name)) {
        // Add a message to the Storage queue,
        // which is the name passed to the function.
        context.bindings.msg = (req.query.name || req.body.name);
        context.res = {
            // status: 200, /* Defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
};

Adjon hozzá egy kódot, amely a msg kimeneti kötési objektumot context.bindings használja egy üzenetsor-üzenet létrehozásához. Adja hozzá ezt a kódot az context.res utasítás előtt.

context.bindings.msg = name;

Ekkor a függvénynek a következőképpen kell kinéznie:

import { AzureFunction, Context, HttpRequest } from "@azure/functions"

const httpTrigger: AzureFunction = async function (context: Context, req: HttpRequest): Promise<void> {
    context.log('HTTP trigger function processed a request.');
    const name = (req.query.name || (req.body && req.body.name));

    if (name) {
        // Add a message to the storage queue, 
        // which is the name passed to the function.
        context.bindings.msg = name; 
        // Send a "hello" response.
        context.res = {
            // status: 200, /* Defaults to 200 */
            body: "Hello " + (req.query.name || req.body.name)
        };
    }
    else {
        context.res = {
            status: 400,
            body: "Please pass a name on the query string or in the request body"
        };
    }
};

export default httpTrigger;

Adjon hozzá egy kódot, amely a Push-OutputBinding parancsmag használatával szöveget ír az üzenetsorba a msg kimeneti kötés használatával. Adja hozzá ezt a kódot, mielőtt beállítja az OK állapotot az if utasításban.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

Ekkor a függvénynek a következőképpen kell kinéznie:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

Adjon hozzá egy kódot, amely a msg kimeneti kötési objektumot használja egy üzenetsor-üzenet létrehozásához. Adja hozzá ezt a kódot, mielőtt a metódus visszatér.

if (!string.IsNullOrEmpty(name))
{
    // Add a message to the output collection.
    msg.Add(name);
}

Ekkor a függvénynek a következőképpen kell kinéznie:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic data = JsonConvert.DeserializeObject(requestBody);
    name = name ?? data?.name;

    if (!string.IsNullOrEmpty(name))
    {
        // Add a message to the output collection.
        msg.Add(name);
    }
    return name != null
        ? (ActionResult)new OkObjectResult($"Hello, {name}")
        : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
}

Most az új msg paraméter használatával írhat a kimeneti kötésbe a függvénykódból. Adja hozzá a következő kódsort a sikeres válasz előtt a kimeneti kötés értékének name hozzáadásához msg .

msg.setValue(name);

Kimeneti kötés használatakor nem kell az Azure Storage SDK-kódot használnia a hitelesítéshez, az üzenetsor-referenciák lekéréséhez vagy az adatok írásához. A Functions-futtatókörnyezet és az üzenetsor kimeneti kötése végrehajtja ezeket a feladatokat.

A run metódusnak most az alábbi példához hasonlóan kell kinéznie:

public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String query = request.getQueryParameters().get("name");
    String name = request.getBody().orElse(query);

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

        return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
    }
}

A tesztek frissítése

Mivel az archetípus egy tesztkészletet is létrehoz, frissítenie kell ezeket a teszteket, hogy kezelni tudja a metódusaláírás új msg paraméterét run .

Keresse meg a tesztkód helyét az src/test/java területen, nyissa meg a Függvény.java projektfájlt, és cserélje le a kódsort //Invoke a következő kódra:

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

A rendszerkép frissítése a beállításjegyzékben

  1. Futtassa docker build újra a gyökérmappában, és ezúttal frissítse a címke verzióját a következőre v1.0.1: . A korábbiakhoz hasonlóan cserélje le <docker_id> a Docker Hub fiókazonosítóját.

    docker build --tag <docker_id>/azurefunctionsimage:v1.0.1 .

  2. Küldje vissza a frissített képet az adattárba a következővel docker push: .

    docker push <docker_id>/azurefunctionsimage:v1.0.1

  3. Mivel konfigurálta a folyamatos teljesítést, a rendszerkép frissítése a beállításjegyzékben ismét automatikusan frissíti a függvényalkalmazást az Azure-ban.

Az üzenet megtekintése az Azure Storage-üzenetsorban

A böngészőben használja ugyanazt az URL-címet, mint korábban a függvény meghívásához. A böngészőnek ugyanazt a választ kell megjelenítenie, mint korábban, mert nem módosította a függvénykód ezen részét. A hozzáadott kód azonban írt egy üzenetet az name URL-paraméterrel a outqueue tárolási üzenetsorba.

Az üzenetsort megtekintheti a Azure Portal vagy a Microsoft Azure Storage Explorer. Az üzenetsort az Azure CLI-ben is megtekintheti az alábbi lépésekben leírtak szerint:

  1. Nyissa meg a függvényprojekt local.setting.json fájlját, és másolja ki a kapcsolati sztring értéket. Egy terminálban vagy parancsablakban futtassa a következő parancsot egy környezeti változó létrehozásáhozAZURE_STORAGE_CONNECTION_STRING, és illessze be az adott kapcsolati sztring a <MY_CONNECTION_STRING>helyére. (Ez a környezeti változó azt jelenti, hogy nem kell megadnia a kapcsolati sztring minden további parancshoz az --connection-string argumentum használatával.)

    export AZURE_STORAGE_CONNECTION_STRING="<MY_CONNECTION_STRING>"

  2. (Nem kötelező) az storage queue list A parancs használatával megtekintheti a társorokat a fiókjában. A parancs kimenetének tartalmaznia kell egy üzenetsort, outqueueamely akkor lett létrehozva, amikor a függvény az első üzenetét az üzenetsorba írta.

    az storage queue list --output tsv

  3. az storage message get A parancs használatával olvassa be az üzenetet ebből az üzenetsorból, amelynek a függvény korábbi tesztelése során megadott értéknek kell lennie. A parancs felolvassa és eltávolítja az első üzenetet az üzenetsorból.

    echo `echo $(az storage message get --queue-name outqueue -o tsv --query '[].{Message:content}') | base64 --decode`

    Mivel az üzenettörzs base64 kódolású, az üzenetet a megjelenítés előtt dekódolni kell. A végrehajtás az storage message getután az üzenet el lesz távolítva az üzenetsorból. Ha csak egy üzenet volt benne outqueue, nem fog üzenetet lekérni, amikor másodszor futtatja ezt a parancsot, hanem hibaüzenetet kap.

Az erőforrások eltávolítása

Ha az oktatóanyagban létrehozott erőforrások használatával szeretné folytatni az Azure-függvény használatát, az összes erőforrást helyben hagyhatja. Mivel prémium szintű csomagot hozott létre Azure Functions, napi egy vagy két USD folyamatos költségekkel kell számolnia.

A folyamatos költségek elkerülése érdekében törölje az AzureFunctionsContainers-rg erőforráscsoportot az adott csoport összes erőforrásának törléséhez:

az group delete --name AzureFunctionsContainers-rg

Következő lépések