Kurz: Vytvoření funkce v Javě s triggerem centra událostí a výstupní vazbou služby Azure Cosmos DB

  • Článek

V tomto kurzu se dozvíte, jak pomocí Azure Functions vytvořit funkci Java, která analyzuje nepřetržitý proud dat o teplotě a tlaku. Události centra událostí, které představují čtení snímačů, aktivují funkci. Funkce zpracuje data události a pak přidá položky stavu do instance služby Azure Cosmos DB.

V tomto kurzu:

  • Vytvářejte a konfigurujte prostředky Azure pomocí Azure CLI.
  • Vytvářejte a testujte funkce Javy, které s těmito prostředky pracují.
  • Nasaďte své funkce do Azure a monitorujte je pomocí služby Application Přehledy.

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet Azure před tím, než začnete.

Předpoklady

K dokončení tohoto kurzu musíte mít nainstalovanou následující:

Důležité

Aby JAVA_HOME bylo možné dokončit tento kurz, musí být proměnná prostředí nastavená na umístění instalace sady JDK.

Pokud dáváte přednost použití kódu pro tento kurz přímo, podívejte se na ukázkové úložiště java-functions-eventhub-cosmosdb .

Vytvoření zdrojů Azure

V tomto kurzu budete potřebovat tyto prostředky:

  • Skupina prostředků obsahující ostatní prostředky
  • Obor názvů služby Event Hubs, centrum událostí a autorizační pravidlo
  • Účet, databáze a kolekce Azure Cosmos DB
  • Aplikace funkcí a účet úložiště pro hostování

V následujících částech se dozvíte, jak tyto prostředky vytvořit pomocí Azure CLI.

Nastavení proměnných prostředí

Dále vytvořte několik proměnných prostředí pro názvy a umístění prostředků, které vytvoříte. Použijte následující příkazy a zástupné symboly nahraďte <value> hodnotami podle vašeho výběru. Hodnoty by měly odpovídat pravidlům a omezením pojmenování prostředků Azure. Pro proměnnou LOCATION použijte jednu z hodnot vytvořených příkazem 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>

Zbytek tohoto kurzu používá tyto proměnné. Mějte na paměti, že tyto proměnné se uchovávají jenom po dobu trvání aktuální relace Azure CLI nebo Cloud Shellu. Pokud použijete jiné okno místního terminálu nebo vyprší časový limit relace Cloud Shellu, budete muset tyto příkazy spustit znovu.

Vytvoření skupiny zdrojů

Azure používá skupiny prostředků ke shromažďování všech souvisejících prostředků ve vašem účtu. Díky tomu je můžete zobrazit jako jednotku a odstranit je jediným příkazem, když s nimi budete hotovi.

Pomocí následujícího příkazu vytvořte skupinu prostředků:

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

Vytvoření centra událostí

Dále pomocí následujících příkazů vytvořte obor názvů služby Azure Event Hubs, centrum událostí a autorizační pravidlo:

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

Obor názvů služby Event Hubs obsahuje skutečné centrum událostí a autorizační pravidlo. Autorizační pravidlo umožňuje vašim funkcím posílat zprávy do centra a naslouchat odpovídajícím událostem. Jedna funkce odesílá zprávy, které představují telemetrická data. Jiná funkce naslouchá událostem, analyzuje data událostí a ukládá výsledky ve službě Azure Cosmos DB.

Vytvoření služby Azure Cosmos DB

Dále pomocí následujících příkazů vytvořte účet, databázi a kolekci Azure Cosmos DB:

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'

Hodnota partition-key-path rozdělí vaše data na temperatureStatus základě hodnoty každé položky. Klíč oddílu umožňuje službě Azure Cosmos DB zvýšit výkon rozdělením dat na různé podmnožina, ke kterým může přistupovat nezávisle.

Vytvoření účtu úložiště a aplikace funkcí

Dále vytvořte účet Azure Storage, který vyžaduje Služba Azure Functions, a pak vytvořte aplikaci funkcí. Použijte následující příkazy:

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

az functionapp create Když příkaz vytvoří aplikaci funkcí, vytvoří také prostředek aplikace Přehledy se stejným názvem. Aplikace funkcí se automaticky nakonfiguruje s nastavením s názvemAPPINSIGHTS_INSTRUMENTATIONKEY, které ho připojí k Přehledy aplikace. Telemetrii aplikace můžete zobrazit po nasazení funkcí do Azure, jak je popsáno dále v tomto kurzu.

Konfigurace aplikace funkcí

Aby aplikace funkcí fungovala správně, musí mít přístup k ostatním prostředkům. V následujících částech se dozvíte, jak nakonfigurovat aplikaci funkcí tak, aby běžela na místním počítači.

Načtení připojovací řetězec prostředků

Pomocí následujících příkazů načtěte úložiště, centrum událostí a azure Cosmos DB připojovací řetězec a uložte je do proměnných prostředí:

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

Tyto proměnné jsou nastavené na hodnoty načtené z příkazů Azure CLI. Každý příkaz používá dotaz JMESPath k extrahování připojovací řetězec z vrácené datové části JSON. Připojovací řetězec se také zobrazují pomocíecho, abyste si mohli ověřit, že byly úspěšně načteny.

Aktualizace nastavení aplikace funkcí

Potom pomocí následujícího příkazu přeneste hodnoty připojovací řetězec do nastavení aplikace ve vašem účtu Azure Functions:

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

Vaše prostředky Azure jsou teď vytvořené a nakonfigurované tak, aby správně spolupracovaly.

Vytvoření a otestování funkcí

Dále vytvoříte projekt na místním počítači, přidáte kód Java a otestujete ho. Použijete příkazy, které pracují s modulem plug-in Azure Functions pro Maven a Azure Functions Core Tools. Vaše funkce se budou spouštět místně, ale budou používat cloudové prostředky, které jste vytvořili. Jakmile funkce místně zpracují, můžete je pomocí Mavenu nasadit do cloudu a sledovat, jak se data a analýzy hromadí.

Pokud jste k vytvoření prostředků použili Cloud Shell, nebudete se k Azure připojovat místně. V takovém případě pomocí az login příkazu spusťte proces přihlášení založený na prohlížeči. V případě potřeby nastavte výchozí předplatné s az account set --subscription id předplatného. Nakonec spusťte následující příkazy, které znovu vytvoří některé proměnné prostředí na místním počítači. <value> Zástupné symboly nahraďte stejnými hodnotami, které jste použili dříve.

RESOURCE_GROUP=<value>
FUNCTION_APP=<value>

Vytvoření projektu místních funkcí

Pomocí následujícího příkazu Mavenu vytvořte projekt funkcí a přidejte požadované závislosti.

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

Tento příkaz vygeneruje několik souborů ve telemetry-functions složce:

  • Soubor pom.xml pro použití s Mavenem
  • Soubor local.settings.json pro uložení nastavení aplikace pro místní testování
  • host.json Soubor, který umožňuje sadu rozšíření Azure Functions, vyžadovanou pro výstupní vazbu služby Azure Cosmos DB ve funkci analýzy dat
  • Function.java Soubor, který obsahuje výchozí implementaci funkce
  • Několik testovacích souborů, které tento kurz nepotřebuje

Abyste se vyhnuli chybám kompilace, budete muset testovací soubory odstranit. Spuštěním následujících příkazů přejděte do nové složky projektu a odstraňte testovací složku:

cd telemetry-functions
rm -r src/test

Načtení nastavení aplikace funkcí pro místní použití

Pro místní testování bude projekt funkcí potřebovat připojovací řetězec, které jste přidali do aplikace funkcí v Azure dříve v tomto kurzu. Použijte následující příkaz Azure Functions Core Tools, který načte všechna nastavení aplikace funkcí uložená v cloudu a přidá je do souboru local.settings.json :

func azure functionapp fetch-app-settings $FUNCTION_APP

Přidání kódu Java

Dále otevřete Function.java soubor a nahraďte jeho obsah následujícím kódem.

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);
    }
}

Jak vidíte, tento soubor obsahuje dvě funkce generateSensorData a processSensorData. Funkce generateSensorData simuluje senzor, který odesílá hodnoty teploty a tlaku do centra událostí. Trigger časovače spustí funkci každých 10 sekund a výstupní vazba centra událostí odešle návratovou hodnotu do centra událostí.

Když centrum událostí obdrží zprávu, vygeneruje událost. Funkce processSensorData se spustí, když přijme událost. Potom zpracuje data událostí a pomocí výstupní vazby Azure Cosmos DB odešle výsledky do služby Azure Cosmos DB.

Data používaná těmito funkcemi se ukládají pomocí třídy s názvem TelemetryItem, kterou budete muset implementovat. Vytvořte nový soubor volaný TelemetryItem.java ve stejném umístění jako Function.java a přidejte následující kód:

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;
    }
}

Spusťte místně .

Teď můžete sestavovat a spouštět funkce místně a zobrazovat data ve službě Azure Cosmos DB.

K sestavení a spuštění funkcí použijte následující příkazy Mavenu:

mvn clean package
mvn azure-functions:run

Po některých sestavách a spouštěcích zprávách se zobrazí výstup podobný následujícímu příkladu při každém spuštění funkcí:

[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)

Pak můžete přejít na web Azure Portal a přejít na svůj účet služby Azure Cosmos DB. Vyberte Průzkumník dat, rozbalte TelemetryInfo a pak vyberte Položky , abyste zobrazili data, když dorazí.

Azure Cosmos DB Data Explorer

Nasazení do Azure a zobrazení telemetrie aplikací

Nakonec můžete aplikaci nasadit do Azure a ověřit, že funguje stejně jako místně.

Nasaďte projekt do Azure pomocí následujícího příkazu:

mvn azure-functions:deploy

Vaše funkce se teď spouštějí v Azure a stále shromažďují data ve službě Azure Cosmos DB. Nasazenou aplikaci funkcí můžete zobrazit na webu Azure Portal a zobrazit telemetrii aplikace prostřednictvím připojeného prostředku aplikace Přehledy, jak je znázorněno na následujících snímcích obrazovky:

Live Metrics Stream:

Application Insights Live Metrics Stream

Výkon:

Application Insights Performance blade

Vyčištění prostředků

Pokud jste už s prostředky Azure vytvořenými v tomto kurzu skončili, můžete je pomocí následujícího příkazu odstranit:

az group delete --name $RESOURCE_GROUP

Další kroky

V tomto kurzu jste zjistili, jak vytvořit funkci Azure, která zpracovává události centra událostí a aktualizuje instanci služby Azure Cosmos DB. Další informace najdete v příručce pro vývojáře v Javě pro Azure Functions. Informace o použitých poznámkách najdete v referenčních informacích k webu com.microsoft.azure.functions.annotation .

V tomto kurzu jste použili proměnné prostředí a nastavení aplikace k ukládání tajných kódů, jako jsou připojovací řetězec. Informace o ukládání těchto tajných kódů ve službě Azure Key Vault najdete v tématu Použití odkazů služby Key Vault pro App Service a Azure Functions.

Dále se dozvíte, jak používat CI/CD služby Azure Pipelines pro automatizované nasazení:

Sestavení a nasazení Java pro Azure Functions