Megosztás a következőn keresztül:

Oktatóanyag: Függvény létrehozása Java-ban egy Event Hub-eseményindítóval és egy Azure Cosmos DB kimeneti kötéssel

  • Cikk

Ez az oktatóanyag bemutatja, hogyan hozhat létre olyan Java-függvényt az Azure Functions használatával, amely folyamatosan elemzi a hőmérséklet- és nyomásadatokat. Az érzékelőolvasásokat jelképező eseményközpont-események aktiválják a függvényt. A függvény feldolgozza az eseményadatokat, majd állapotbejegyzéseket ad hozzá egy Azure Cosmos DB-példányhoz.

Ebben az oktatóanyagban a következőket fogja elkönyvelni:

  • Azure-erőforrások létrehozása és konfigurálása az Azure CLI használatával.
  • Az erőforrásokkal kommunikáló Java-függvények létrehozása és tesztelése.
  • Helyezze üzembe a függvényeket az Azure-ban, és figyelje őket az Alkalmazás Elemzések segítségével.

If you don't have an Azure subscription, create an Azure free account before you begin.

Előfeltételek

Az oktatóanyag elvégzéséhez a következőket kell telepítenie:

Fontos

Az JAVA_HOME oktatóanyag elvégzéséhez a környezeti változót a JDK telepítési helyére kell állítani.

Ha az oktatóanyag kódját szeretné közvetlenül használni, tekintse meg a java-functions-eventhub-cosmosdb mintaadattárat.

Azure-erőforrások létrehozása

Ebben az oktatóanyagban a következő erőforrásokra lesz szüksége:

  • A többi erőforrást tartalmazó erőforráscsoport
  • Event Hubs-névtér, eseményközpont és engedélyezési szabály
  • Azure Cosmos DB-fiók, -adatbázis és -gyűjtemény
  • Egy függvényalkalmazás és egy tárfiók a üzemeltetéséhez

Az alábbi szakaszok bemutatják, hogyan hozhatja létre ezeket az erőforrásokat az Azure CLI használatával.

Set environment variables

Ezután hozzon létre néhány környezeti változót a létrehozni kívánt erőforrások nevéhez és helyéhez. Használja az alábbi parancsokat, és cserélje le a <value> helyőrzőket az Ön által választott értékekre. Az értékeknek meg kell felelniük az Azure-erőforrások elnevezési szabályainak és korlátozásainak. A változóhoz LOCATION használja a parancs által előállított értékek egyikét az functionapp list-consumption-locations .

RESOURCE_GROUP=<value>
EVENT_HUB_NAMESPACE=<value>
EVENT_HUB_NAME=<value>
EVENT_HUB_AUTHORIZATION_RULE=<value>
COSMOS_DB_ACCOUNT=<value>
STORAGE_ACCOUNT=<value>
FUNCTION_APP=<value>
LOCATION=<value>

Az oktatóanyag többi része ezeket a változókat használja. Vegye figyelembe, hogy ezek a változók csak az aktuális Azure CLI- vagy Cloud Shell-munkamenet idejére maradnak meg. Ha másik helyi terminálablakot használ, vagy a Cloud Shell-munkamenet túllépi az időkorlátot, újra le kell futtatnia ezeket a parancsokat.

Erőforráscsoport létrehozása

Az Azure erőforráscsoportokkal gyűjti össze az összes kapcsolódó erőforrást a fiókjában. Így egységként tekintheti meg őket, és egyetlen paranccsal törölheti őket, ha végzett velük.

Erőforráscsoport létrehozásához használja a következő parancsot:

az group create \
    --name $RESOURCE_GROUP \
    --location $LOCATION

Eseményközpont létrehozása

Ezután hozzon létre egy Azure Event Hubs-névteret, eseményközpontot és engedélyezési szabályt az alábbi parancsokkal:

az eventhubs namespace create \
    --resource-group $RESOURCE_GROUP \
    --name $EVENT_HUB_NAMESPACE
az eventhubs eventhub create \
    --resource-group $RESOURCE_GROUP \
    --name $EVENT_HUB_NAME \
    --namespace-name $EVENT_HUB_NAMESPACE \
    --message-retention 1
az eventhubs eventhub authorization-rule create \
    --resource-group $RESOURCE_GROUP \
    --name $EVENT_HUB_AUTHORIZATION_RULE \
    --eventhub-name $EVENT_HUB_NAME \
    --namespace-name $EVENT_HUB_NAMESPACE \
    --rights Listen Send

Az Event Hubs-névtér tartalmazza a tényleges eseményközpontot és annak engedélyezési szabályát. Az engedélyezési szabály lehetővé teszi, hogy a függvények üzeneteket küldjenek a központnak, és figyeljék a megfelelő eseményeket. Az egyik függvény telemetriai adatokat képviselő üzeneteket küld. Egy másik függvény figyeli az eseményeket, elemzi az eseményadatokat, és az eredményeket az Azure Cosmos DB-ben tárolja.

Azure Cosmos DB létrehozása

Ezután hozzon létre egy Azure Cosmos DB-fiókot, -adatbázist és -gyűjteményt az alábbi parancsokkal:

az cosmosdb create \
    --resource-group $RESOURCE_GROUP \
    --name $COSMOS_DB_ACCOUNT
az cosmosdb sql database create \
    --resource-group $RESOURCE_GROUP \
    --account-name $COSMOS_DB_ACCOUNT \
    --name TelemetryDb
az cosmosdb sql container create \
    --resource-group $RESOURCE_GROUP \
    --account-name $COSMOS_DB_ACCOUNT \
    --database-name TelemetryDb \
    --name TelemetryInfo \
    --partition-key-path '/temperatureStatus'

Az partition-key-path érték az egyes elemek értéke alapján particionálja az temperatureStatus adatokat. A partíciókulcs lehetővé teszi az Azure Cosmos DB számára a teljesítmény növelését azáltal, hogy az adatokat különböző részhalmazokra osztja, amelyekhez egymástól függetlenül férhetnek hozzá.

Tárfiók és függvényalkalmazás létrehozása

Ezután hozzon létre egy Azure Storage-fiókot, amelyet az Azure Functions igényel, majd hozza létre a függvényalkalmazást. Használja a következő parancsokat:

az storage account create \
    --resource-group $RESOURCE_GROUP \
    --name $STORAGE_ACCOUNT \
    --sku Standard_LRS
az functionapp create \
    --resource-group $RESOURCE_GROUP \
    --name $FUNCTION_APP \
    --storage-account $STORAGE_ACCOUNT \
    --consumption-plan-location $LOCATION \
    --runtime java \
    --functions-version 3

Amikor a az functionapp create parancs létrehozza a függvényalkalmazást, egy alkalmazás Elemzések erőforrást is létrehoz ugyanazzal a névvel. A függvényalkalmazás automatikusan konfigurálva van egy olyan beállítássalAPPINSIGHTS_INSTRUMENTATIONKEY, amely az Alkalmazás Elemzések csatlakoztatja. Az alkalmazástelemetria a függvények Azure-ban való üzembe helyezése után tekinthető meg, az oktatóanyag későbbi részében leírtak szerint.

A függvényalkalmazás konfigurálása

A függvényalkalmazásnak hozzá kell férnie a többi erőforráshoz a megfelelő működéshez. Az alábbi szakaszok bemutatják, hogyan konfigurálhatja a függvényalkalmazást úgy, hogy az a helyi gépen fusson.

Erőforrás-kapcsolati sztring lekérése

A következő parancsokkal lekérheti a tárterületet, az eseményközpontot és az Azure Cosmos DB-kapcsolati sztring, és mentheti őket környezeti változókba:

AZURE_WEB_JOBS_STORAGE=$( \
    az storage account show-connection-string \
        --name $STORAGE_ACCOUNT \
        --query connectionString \
        --output tsv)
echo $AZURE_WEB_JOBS_STORAGE
EVENT_HUB_CONNECTION_STRING=$( \
    az eventhubs eventhub authorization-rule keys list \
        --resource-group $RESOURCE_GROUP \
        --name $EVENT_HUB_AUTHORIZATION_RULE \
        --eventhub-name $EVENT_HUB_NAME \
        --namespace-name $EVENT_HUB_NAMESPACE \
        --query primaryConnectionString \
        --output tsv)
echo $EVENT_HUB_CONNECTION_STRING
COSMOS_DB_CONNECTION_STRING=$( \
    az cosmosdb keys list \
        --resource-group $RESOURCE_GROUP \
        --name $COSMOS_DB_ACCOUNT \
        --type connection-strings \
        --query 'connectionStrings[0].connectionString' \
        --output tsv)
echo $COSMOS_DB_CONNECTION_STRING

Ezek a változók az Azure CLI-parancsokból lekért értékekre vannak beállítva. Minden parancs egy JMESPath-lekérdezéssel nyeri ki a kapcsolati sztring a visszaadott JSON hasznos adatokból. A kapcsolati sztring is megjelenikecho, így meggyőződhet arról, hogy sikeresen lekérte őket.

A függvényalkalmazás beállításainak frissítése

Ezután az alábbi paranccsal vigye át a kapcsolati sztring értékeket az Azure Functions-fiók alkalmazásbeállításaiba:

az functionapp config appsettings set \
    --resource-group $RESOURCE_GROUP \
    --name $FUNCTION_APP \
    --settings \
        AzureWebJobsStorage=$AZURE_WEB_JOBS_STORAGE \
        EventHubConnectionString=$EVENT_HUB_CONNECTION_STRING \
        CosmosDBConnectionSetting=$COSMOS_DB_CONNECTION_STRING

Az Azure-erőforrások most már létre lettek hozva, és konfigurálva lettek a megfelelő együttműködésre.

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

Ezután létrehoz egy projektet a helyi gépen, hozzáad egy Java-kódot, és teszteli azt. Olyan parancsokat fog használni, amelyek a MavenHez készült Azure Functions beépülő modullal és az Azure Functions Core Tools szolgáltatással működnek. A függvények helyileg fognak futni, de a létrehozott felhőalapú erőforrásokat fogják használni. Miután a függvények helyileg működnek, a Maven használatával üzembe helyezheti őket a felhőben, és megfigyelheti, ahogy az adatok és az elemzések felhalmozódnak.

Ha a Cloud Shell használatával hozta létre az erőforrásokat, akkor nem fog helyileg csatlakozni az Azure-hoz. Ebben az esetben a az login parancs használatával indítsa el a böngészőalapú bejelentkezési folyamatot. Ezután szükség esetén állítsa be az alapértelmezett előfizetést az account set --subscription , majd az előfizetés azonosítóját. Végül futtassa az alábbi parancsokat néhány környezeti változó újbóli létrehozásához a helyi gépen. Cserélje le a <value> helyőrzőket ugyanazokra az értékekre, amelyeket korábban használt.

RESOURCE_GROUP=<value>
FUNCTION_APP=<value>

Helyi függvényprojekt létrehozása

A következő Maven-paranccsal hozzon létre egy függvényprojektet, és adja hozzá a szükséges függőségeket.

mvn archetype:generate --batch-mode \
    -DarchetypeGroupId=com.microsoft.azure \
    -DarchetypeArtifactId=azure-functions-archetype \
    -DappName=$FUNCTION_APP \
    -DresourceGroup=$RESOURCE_GROUP \
    -DappRegion=$LOCATION \
    -DgroupId=com.example \
    -DartifactId=telemetry-functions

Ez a parancs több fájlt hoz létre egy telemetry-functions mappában:

  • A pom.xml Mavenhez használható fájl
  • A local.settings.json helyi tesztelés alkalmazásbeállításainak tárolására szolgáló fájl
  • Egy host.json fájl, amely lehetővé teszi az Azure Functions-bővítménycsomagot, amely szükséges az Azure Cosmos DB kimeneti kötéséhez az adatelemzési függvényben
  • Alapértelmezett Function.java függvény-implementációt tartalmazó fájl
  • Néhány tesztfájl, amelyekre az oktatóanyagnak nincs szüksége

A fordítási hibák elkerülése érdekében törölnie kell a tesztfájlokat. Futtassa az alábbi parancsokat az új projektmappához való navigáláshoz és a tesztmappa törléséhez:

cd telemetry-functions
rm -r src/test

A függvényalkalmazás beállításainak lekérése helyi használatra

A helyi teszteléshez a függvényprojektnek szüksége lesz azokra a kapcsolati sztring, amelyeket az oktatóanyag korábbi részében hozzáadott a függvényalkalmazáshoz az Azure-ban. Használja a következő Azure Functions Core Tools parancsot, amely lekéri a felhőben tárolt összes függvényalkalmazás-beállítást, és hozzáadja őket a local.settings.json fájlhoz:

func azure functionapp fetch-app-settings $FUNCTION_APP

Java-kód hozzáadása

Ezután nyissa meg a Function.java fájlt, és cserélje le a tartalmat a következő kódra.

package com.example;

import com.example.TelemetryItem.status;
import com.microsoft.azure.functions.annotation.Cardinality;
import com.microsoft.azure.functions.annotation.CosmosDBOutput;
import com.microsoft.azure.functions.annotation.EventHubOutput;
import com.microsoft.azure.functions.annotation.EventHubTrigger;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.TimerTrigger;
import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.OutputBinding;

public class Function {

    @FunctionName("generateSensorData")
    @EventHubOutput(
        name = "event",
        eventHubName = "", // blank because the value is included in the connection string
        connection = "EventHubConnectionString")
    public TelemetryItem generateSensorData(
        @TimerTrigger(
            name = "timerInfo",
            schedule = "*/10 * * * * *") // every 10 seconds
            String timerInfo,
        final ExecutionContext context) {

        context.getLogger().info("Java Timer trigger function executed at: "
            + java.time.LocalDateTime.now());
        double temperature = Math.random() * 100;
        double pressure = Math.random() * 50;
        return new TelemetryItem(temperature, pressure);
    }

    @FunctionName("processSensorData")
    public void processSensorData(
        @EventHubTrigger(
            name = "msg",
            eventHubName = "", // blank because the value is included in the connection string
            cardinality = Cardinality.ONE,
            connection = "EventHubConnectionString")
            TelemetryItem item,
        @CosmosDBOutput(
            name = "databaseOutput",
            databaseName = "TelemetryDb",
            containerName = "TelemetryInfo",
            connection = "CosmosDBConnectionSetting")
            OutputBinding<TelemetryItem> document,
        final ExecutionContext context) {

        context.getLogger().info("Event hub message received: " + item.toString());

        if (item.getPressure() > 30) {
            item.setNormalPressure(false);
        } else {
            item.setNormalPressure(true);
        }

        if (item.getTemperature() < 40) {
            item.setTemperatureStatus(status.COOL);
        } else if (item.getTemperature() > 90) {
            item.setTemperatureStatus(status.HOT);
        } else {
            item.setTemperatureStatus(status.WARM);
        }

        document.setValue(item);
    }
}

Mint látható, ez a fájl két függvényt generateSensorData és processSensorData. A generateSensorData függvény szimulál egy érzékelőt, amely hőmérséklet- és nyomásméréseket küld az eseményközpontnak. Az időzítő eseményindítója 10 másodpercenként futtatja a függvényt, és egy eseményközpont kimeneti kötése elküldi a visszatérési értéket az eseményközpontnak.

Amikor az eseményközpont megkapja az üzenetet, létrehoz egy eseményt. A processSensorData függvény akkor fut, amikor megkapja az eseményt. Ezután feldolgozza az eseményadatokat, és egy Azure Cosmos DB kimeneti kötés használatával elküldi az eredményeket az Azure Cosmos DB-nek.

A függvények által használt adatokat egy úgynevezett TelemetryItemosztály tárolja, amelyet implementálnia kell. Hozzon létre egy új fájlt, amely ugyanazon a helyen van meghívva TelemetryItem.java , Function.java és adja hozzá a következő kódot:

package com.example;

public class TelemetryItem {

    private String id;
    private double temperature;
    private double pressure;
    private boolean isNormalPressure;
    private status temperatureStatus;
    static enum status {
        COOL,
        WARM,
        HOT
    }

    public TelemetryItem(double temperature, double pressure) {
        this.temperature = temperature;
        this.pressure = pressure;
    }

    public String getId() {
        return id;
    }

    public double getTemperature() {
        return temperature;
    }

    public double getPressure() {
        return pressure;
    }

    @Override
    public String toString() {
        return "TelemetryItem={id=" + id + ",temperature="
            + temperature + ",pressure=" + pressure + "}";
    }

    public boolean isNormalPressure() {
        return isNormalPressure;
    }

    public void setNormalPressure(boolean isNormal) {
        this.isNormalPressure = isNormal;
    }

    public status getTemperatureStatus() {
        return temperatureStatus;
    }

    public void setTemperatureStatus(status temperatureStatus) {
        this.temperatureStatus = temperatureStatus;
    }
}

A futtatása helyileg

Mostantól helyileg is létrehozhatja és futtathatja a függvényeket, és láthatja, hogy az adatok megjelennek az Azure Cosmos DB-ben.

A függvények létrehozásához és futtatásához használja a következő Maven-parancsokat:

mvn clean package
mvn azure-functions:run

Néhány buildelési és indítási üzenet után a függvények futtatásakor az alábbi példához hasonló kimenet jelenik meg:

[10/22/19 4:01:30 AM] Executing 'Functions.generateSensorData' (Reason='Timer fired at 2019-10-21T21:01:30.0016769-07:00', Id=c1927c7f-4f70-4a78-83eb-bc077d838410)
[10/22/19 4:01:30 AM] Java Timer trigger function executed at: 2019-10-21T21:01:30.015
[10/22/19 4:01:30 AM] Function "generateSensorData" (Id: c1927c7f-4f70-4a78-83eb-bc077d838410) invoked by Java Worker
[10/22/19 4:01:30 AM] Executed 'Functions.generateSensorData' (Succeeded, Id=c1927c7f-4f70-4a78-83eb-bc077d838410)
[10/22/19 4:01:30 AM] Executing 'Functions.processSensorData' (Reason='', Id=f4c3b4d7-9576-45d0-9c6e-85646bb52122)
[10/22/19 4:01:30 AM] Event hub message received: TelemetryItem={id=null,temperature=32.728691307527015,pressure=10.122563042388165}
[10/22/19 4:01:30 AM] Function "processSensorData" (Id: f4c3b4d7-9576-45d0-9c6e-85646bb52122) invoked by Java Worker
[10/22/19 4:01:38 AM] Executed 'Functions.processSensorData' (Succeeded, Id=1cf0382b-0c98-4cc8-9240-ee2a2f71800d)

Ezután megnyithatja az Azure Portalt , és megnyithatja az Azure Cosmos DB-fiókját. Válassza az Adatkezelőt, bontsa ki a TelemetryInfo elemet, majd válassza az Elemek lehetőséget az adatok érkezéskor való megtekintéséhez.

Azure Cosmos DB Data Explorer

Üzembe helyezés az Azure-ban és alkalmazástelemetria megtekintése

Végül üzembe helyezheti az alkalmazást az Azure-ban, és ellenőrizheti, hogy továbbra is ugyanúgy működik-e, mint helyileg.

Telepítse a projektet az Azure-ban a következő paranccsal:

mvn azure-functions:deploy

A függvények most már az Azure-ban futnak, és továbbra is gyűjtik az adatokat az Azure Cosmos DB-ben. Az üzembe helyezett függvényalkalmazást megtekintheti az Azure Portalon, és megtekintheti az alkalmazás telemetriáját a csatlakoztatott alkalmazás Elemzések erőforráson keresztül, ahogyan az alábbi képernyőképeken látható:

Élő metrikák streamje:

Application Insights Live Metrics Stream

Teljesítmény:

Application Insights Performance blade

Clean up resources

Ha végzett az oktatóanyagban létrehozott Azure-erőforrásokkal, az alábbi parancs használatával törölheti őket:

az group delete --name $RESOURCE_GROUP

Következő lépések

Ebben az oktatóanyagban megtanulta, hogyan hozhat létre olyan Azure-függvényt, amely kezeli az Event Hub-eseményeket, és frissít egy Azure Cosmos DB-példányt. További információkért tekintse meg az Azure Functions Java fejlesztői útmutatóját. A használt széljegyzetekről további információt a com.microsoft.azure.functions.annotation referenciában talál.

Ez az oktatóanyag környezeti változókat és alkalmazásbeállításokat használt a titkos kódok, például a kapcsolati sztring tárolására. A titkos kulcsok Azure Key Vaultban való tárolásáról további információt az App Service és az Azure Functions Key Vault-hivatkozásainak használata című témakörben talál.

Ezután megtudhatja, hogyan használhatja az Azure Pipelines CI/CD-t az automatizált üzembe helyezéshez:

Build and deploy Java to Azure Functions