Distribuera serverlösa Java-appar med Quarkus i Azure Functions

I den här artikeln ska du utveckla, skapa och distribuera en serverlös Java-app till Azure Functions med hjälp av Quarkus. Den här artikeln använder Quarkus Funqy och dess inbyggda stöd för Azure Functions HTTP-utlösare för Java. Med Quarkus med Azure Functions får du kraften i Quarkus-programmeringsmodellen med skalning och flexibilitet i Azure Functions. När du är klar kör du serverlösa Quarkus-program på Azure Functions och fortsätter att övervaka din app i Azure.

Förutsättningar

• Azure CLI installerat på din egen dator.
• Ett Azure-konto. Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.
• Java JDK 17 med JAVA_HOME rätt konfigurerad. Den här artikeln skrevs med Java 17 i åtanke, men Azure Functions och Quarkus stöder också äldre versioner av Java.
• Apache Maven 3.8.1+.

Skapa appprojektet

Använd följande kommando för att klona Java-exempelprojektet för den här artikeln. Exemplet finns på GitHub.

git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2023-01-10
cd functions-quarkus

Om du ser ett meddelande om att vara i frånkopplat HEAD-tillstånd är det här meddelandet säkert att ignorera. Eftersom det här dokumentet inte kräver några commits är frånkopplat HEAD-läge lämpligt.

Utforska exempelfunktionen. Öppna filen functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java.

Kör följande kommando. Kommentaren @Funq gör din metod (i det här fallet funqyHello) till en serverlös funktion.

@Funq
public String funqyHello() {
    return "hello funqy";
}

Azure Functions Java har en egen uppsättning Azure-specifika anteckningar, men dessa anteckningar behövs inte när du använder Quarkus på Azure Functions i en enkel kapacitet som vi gör här. Mer information om Azure Functions Java-anteckningar finns i utvecklarguiden för Azure Functions Java.

Om du inte anger något annat är funktionens namn samma som metodnamnet. Du kan också använda följande kommando för att definiera funktionsnamnet med en parameter till kommentaren:

@Funq("alternateName")
public String funqyHello() {
    return "hello funqy";
}

Namnet är viktigt. Det blir en del av REST-URI:n att anropa funktionen, vilket visas senare i artikeln.

Testa funktionen lokalt

Använd mvn för att köra Quarkus dev-läge på din lokala terminal. Genom att köra Quarkus på det här sättet möjliggörs live-omladdning med bakgrundskompilering. När du ändrar dina Java-filer och/eller dina resursfiler och uppdaterar webbläsaren börjar ändringarna gälla automatiskt.

En webbläsaruppdatering utlöser en genomsökning av arbetsytan. Om genomsökningen identifierar några ändringar omkompileras Java-filerna och programmet distribueras om. Din omdistribuerade applikation tjänar förfrågan. Om det finns problem med kompilering eller distribution meddelar en felsida dig.

I följande procedur ersätter du yourResourceGroupName med ett resursgruppsnamn. Funktionsappnamn måste vara globalt unika i hela Azure. Resursgruppsnamn måste vara globalt unika i en prenumeration. Den här artikeln uppnår nödvändig unikhet genom att lägga till resursgruppens namn på funktionsnamnet. Överväg att lägga till en unik identifierare för alla namn som du skapar som måste vara unika. En användbar teknik är att använda dina initialer följt av dagens datum i mmdd format.

Resursgruppen är inte nödvändig för den här delen av instruktionerna, men den krävs senare. För enkelhetens skull kräver Maven-projektet att du definierar egenskapen.

1. Anropa Quarkus utvecklingsläge:

   mvn -DskipTests -DresourceGroup=<yourResourceGroupName> quarkus:dev
   

   Resultatet bör se ut så här:

   ...
   --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
   -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
   --\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
   INFO  [io.quarkus] (Quarkus Main Thread) quarkus-azure-function 1.0-SNAPSHOT on JVM (powered by Quarkus xx.xx.xx.) started in 1.290s. Listening on: http://localhost:8080
   
   INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
   INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, funqy-http, smallrye-context-propagation, vertx]
   
   --
   Tests paused
   Press [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>
   

2. Få åtkomst till funktionen med hjälp CURL av kommandot i den lokala terminalen:

   curl localhost:8080/api/funqyHello
   

   Resultatet bör se ut så här:

   "hello funqy"
   

Lägg till beroendeinjektion i funktionen

Den öppna standardtekniken Jakarta EE Contexts and Dependency Injection (CDI) tillhandahåller beroendeinmatning i Quarkus.

1. Lägg till en ny funktion som använder beroendeinmatning.

   Skapa en GreetingService.java fil i katalogen functions-quarkus/src/main/java/io/quarkus. Använd följande kod som källkod för filen:

   package io.quarkus;
   
   import javax.enterprise.context.ApplicationScoped;
   
   @ApplicationScoped
   public class GreetingService {
   
       public String greeting(String name) {
           return "Welcome to build Serverless Java with Quarkus on Azure Functions, " + name;
       }
   
   }
   

   Spara filen.

   GreetingService är en injicerbar böna som implementerar en greeting() metod. Metoden returnerar ett Welcome... strängmeddelande med en name parameter.

2. Öppna den befintliga filen functions-quarkus/src/main/java/io/quarkus/GreetingFunction.java . Ersätt klassen med följande kod för att lägga till ett nytt gService fält och greeting metoden:

   package io.quarkus;
   
   import javax.inject.Inject;
   import io.quarkus.funqy.Funq;
   
   public class GreetingFunction {
   
       @Inject
       GreetingService gService;
   
       @Funq
       public String greeting(String name) {
           return gService.greeting(name);
       }
   
       @Funq
       public String funqyHello() {
           return "hello funqy";
       }
   
   }
   

   Spara filen.

3. Få åtkomst till den nya greeting-funktionen med hjälp av curl-kommandot i den lokala terminalen:

   curl -d '"Dan"' -X POST localhost:8080/api/greeting
   

   Resultatet bör se ut så här:

   "Welcome to build Serverless Java with Quarkus on Azure Functions, Dan"
   

   Viktigt!

   Med livekodning (kallas även utvecklingsläge) kan du köra appen och göra ändringar i farten. Quarkus kompilerar automatiskt om och läser in appen igen när ändringar görs. Detta är ett kraftfullt och effektivt sätt att utveckla som du kommer att använda i hela den här artikeln.

   Innan du går vidare till nästa steg stoppar du Quarkus dev-läge genom att välja Ctrl+C.

distribuera appen till Azure

1. Om du inte redan har gjort det loggar du in på din Azure-prenumeration med hjälp av följande az login-kommando och följer anvisningarna på skärmen:

   az login
   

   Anteckning

   Om flera Azure-klienter är associerade med dina Azure-autentiseringsuppgifter måste du ange vilken klientorganisation du vill logga in på. Du kan göra detta med hjälp av alternativet --tenant . Exempel: az login --tenant contoso.onmicrosoft.com.

   Fortsätt processen i webbläsaren. Om ingen webbläsare är tillgänglig eller om webbläsaren inte kan öppnas använder du enhetskodflödet med az login --use-device-code.

   När du har loggat in bör utdata på den lokala terminalen se ut ungefär så här:

   xxxxxxx-xxxxx-xxxx-xxxxx-xxxxxxxxx 'Microsoft'
   [
       {
           "cloudName": "AzureCloud",
           "homeTenantId": "xxxxxx-xxxx-xxxx-xxxx-xxxxxxx",
           "id": "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxx",
           "isDefault": true,
           "managedByTenants": [],
           "name": "Contoso account services",
           "state": "Enabled",
           "tenantId": "xxxxxxx-xxxx-xxxx-xxxxx-xxxxxxxxxx",
           "user": {
           "name": "user@contoso.com",
           "type": "user"
           }
       }
   ]
   

2. Skapa och distribuera funktionerna till Azure.

   Den pom.xml fil som du genererade i föregående steg använder azure-functions-maven-plugin. Att köra mvn install genererar konfigurationsfiler och en mellanlagringskatalog som azure-functions-maven-plugin kräver. För yourResourceGroupNameanvänder du det värde som du använde tidigare.

   mvn clean install -DskipTests -DtenantId=<your tenantId from shown previously> -DresourceGroup=<yourResourceGroupName> azure-functions:deploy
   

3. Logga in på Azure under distributionen. Plugin-programmet azure-functions-maven-plugin är konfigurerat för att fråga efter Azure-inloggning varje gång projektet distribueras. Under bygget visas utdata som liknar följande:

   [INFO] Auth type: DEVICE_CODE
   To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code AXCWTLGMP to authenticate.
   

   Gör som utdata säger och autentisera till Azure med hjälp av webbläsaren och den angivna enhetskoden. Många andra autentiserings- och konfigurationsalternativ är tillgängliga. Den fullständiga referensdokumentationen för azure-functions-maven-plugin finns på Azure Functions: Configuration Details(Konfigurationsinformation).

4. Efter autentiseringen ska bygget fortsätta och slutföras. Se till att utdatan innehåller BUILD SUCCESS nära slutet.

   Successfully deployed the artifact to https://quarkus-demo-123451234.azurewebsites.net
   

   Du kan också hitta URL:en för att utlösa funktionen i Azure i utdataloggen:

   [INFO] HTTP Trigger Urls:
   [INFO] 	 quarkus : https://quarkus-azure-functions-http-archetype-20220629204040017.azurewebsites.net/api/{*path}
   

   Det tar ett tag innan distributionen är klar. Under tiden ska vi utforska Azure Functions i Azure Portal.

Få åtkomst till och övervaka den serverlösa funktionen i Azure

Logga in på portalen och se till att du har valt samma klientorganisation och prenumeration som du använde i Azure CLI.

1. Skriv function app i sökfältet överst i Azure Portal och tryck på Enter-tangenten. Funktionsappen ska distribueras och visas med namnet <yourResourceGroupName>-function-quarkus.

   

2. Välj funktionsappen för att visa detaljerad information, till exempel Plats, Prenumeration, URL, Mått och App Service-plan. Välj sedan URL-värdet .

   

3. Bekräfta att välkomstsidan säger att funktionsappen är "igång".

   

4. greeting Anropa funktionen med hjälp av följande curl kommando i den lokala terminalen.

   Viktigt!

   Ersätt YOUR_HTTP_TRIGGER_URL med din egen funktions-URL som du hittar i Azure Portal eller utdata.

   curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting
   

   Utdata bör se ut ungefär så här:

   "Welcome to build Serverless Java with Quarkus on Azure Functions, Dan on Azure"
   

   Du kan också komma åt den andra funktionen (funqyHello) med hjälp av följande curl kommando:

   curl https://YOUR_HTTP_TRIGGER_URL/api/funqyHello
   

   Utdata bör vara desamma som du observerade tidigare:

   "hello funqy"
   

   Om du vill använda den grundläggande måttfunktionen i Azure Portal kan du prova att anropa funktionen i en shell-loopfor:

   for i in {1..100}; do curl -d '"Dan on Azure"' -X POST https://YOUR_HTTP_TRIGGER_URL/api/greeting; done
   

   Efter ett tag visas vissa måttdata i portalen.

   

Nu när du har öppnat din Azure-funktion i portalen finns här fler funktioner som du kan komma åt från portalen:

• Övervaka prestanda för din Azure-funktion. Mer information finns i Övervaka Azure Functions.
• Utforska telemetri. Mer information finns i Analysera Telemetri för Azure Functions i Application Insights.
• Konfigurera loggning. För mer information, se Aktivera körningsloggar för direktuppspelning i Azure Functions.

Rensa resurser

Om du inte behöver dessa resurser kan du ta bort dem genom att köra följande kommando:

az group delete --name <yourResourceGroupName> --yes

Nästa steg

I den här artikeln lärde du dig att:

Mer information om Azure Functions och Quarkus finns i följande artiklar och referenser:

• Utvecklarguide för Azure Functions Java
• Snabbstart: Skapa en Java-funktion i Azure med Visual Studio Code
• Azure Functions-dokumentation
• Quarkus-guide för distribution i Azure