Create and Deploy a Micronaut Gateway Function as an Azure HTTP Function

package com.example;

import io.micronaut.core.annotation.Introspected;
import io.micronaut.core.annotation.NonNull;

import io.micronaut.serde.annotation.Serdeable;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;

@Serdeable
@Introspected (1)
public class StoreItem {

    @NotBlank
    @NonNull
    private final String name;

    private final String description;

    @Min(0)
    private int numberInStorage;

    public StoreItem(String name, String description, int numberInStorage) { (2)
        this.name = name;
        this.description = description;
        this.numberInStorage = numberInStorage;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public Integer getNumberInStorage() {
        return numberInStorage;
    }

    public void setNumberInStorage(Integer numberInStorage) {
        this.numberInStorage = numberInStorage;
    }
}

package com.example;

import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.PathVariable;
import io.micronaut.http.annotation.Post;
import io.micronaut.http.exceptions.HttpStatusException;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import java.util.Collection;
import java.util.stream.Collectors;

import static io.micronaut.http.HttpStatus.BAD_REQUEST;
import static io.micronaut.http.HttpStatus.NOT_FOUND;

@Controller("/store") (1)
class StoreController {

    private final StorageService storageService;

    StoreController(StorageService storageService) {
        this.storageService = storageService;
    } (2)

    @Get("/all") (3)
    Collection<StoreItem> listAllItems() {
        return storageService.getItems();
    }

    @Get("/available") (4)
    Collection<StoreItem> listAvailableItems() {
        return storageService.getItems().stream()
                .filter(i -> i.getNumberInStorage() > 0)
                .collect(Collectors.toList());
    }

    @Post(uri = "/order/{name}/{amount}", consumes = "*/*") (5)
    HttpResponse<StoreItem> orderItem(@NotBlank @PathVariable String name, @Min(1) int amount) {
        if (storageService.findItem(name).isEmpty()) {
            throw new HttpStatusException(NOT_FOUND, "Item '" + name + "' not found");
        }
        try {
            storageService.orderItem(name, amount);
        } catch (StorageService.StorageException e) {
            throw new HttpStatusException(BAD_REQUEST, "Could not order item '" + name + "'. " + e.getMessage());
        }
        return HttpResponse.ok(storageService.findItem(name).orElse(null));
    }
}

package com.example;

import io.micronaut.context.annotation.Property;
import io.micronaut.context.annotation.Requires;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Post;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.http.client.exceptions.HttpClientResponseException;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import jakarta.inject.Singleton;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;

import static io.micronaut.http.HttpStatus.BAD_REQUEST;
import static io.micronaut.http.HttpStatus.NOT_FOUND;
import static io.micronaut.http.HttpStatus.OK;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

@MicronautTest
@Property(name = "use-test-storage-service", value = "true") (1)
class StoreControllerTest {

    @Inject
    StoreClient client;

    @Test
    void testAvailableItems() {
        List<StoreItem> availableItems = client.getAvailable();

        assertEquals(2, availableItems.size());
        assertEquals("pot", availableItems.get(1).getName());
        assertEquals(10, availableItems.get(1).getNumberInStorage());
        assertNotNull(availableItems.get(1).getDescription());
    }

    @Test
    void testNotFoundException() {
        HttpResponse<?> response = client.order("lamp", 1);

        assertEquals(NOT_FOUND, response.getStatus());
    }

    @Test
    void testNotSufficientException() {
        HttpClientResponseException e = assertThrows(HttpClientResponseException.class, () -> {
            client.order("pot", 100);
        });

        assertEquals(BAD_REQUEST, e.getStatus());
    }

    @Test
    void testOrderRequest() {
        StoreItem plate = client.getAll().stream()
            .filter(i -> i.getName().equals("plate"))
            .findFirst().orElse(null);
        assertNotNull(plate);
        assertEquals(100, plate.getNumberInStorage());

        HttpResponse<StoreItem> response = client.order("plate", 10);
        assertEquals(OK, response.getStatus());
        assertNotNull(response.body());
        assertEquals("plate", response.body().getName());
        assertEquals(90, response.body().getNumberInStorage());
    }

    @Singleton
    @Requires(property = "use-test-storage-service", value = "true") (2)
    static class TestStorageService extends DefaultStorageService {
        TestStorageService() {
            items = List.of(
                new StoreItem("plate", "A large plate", 100),
                new StoreItem("pot", "A cooking pot", 10),
                new StoreItem("pan", "A large pan", 0)
            );
        }
    }

    @Client("/store") (3)
    interface StoreClient {
        @Get("/all") (4)
        List<StoreItem> getAll();

        @Get("/available") (4)
        List<StoreItem> getAvailable();

        @Post("/order/{name}/{amount}") (4)
        HttpResponse<StoreItem> order(String name, Integer amount);
    }
}

az provider register --namespace 'Microsoft.ContainerRegistry'

az provider show --namespace Microsoft.ContainerRegistry

az provider register --namespace 'Microsoft.Storage'

az provider show --namespace Microsoft.Storage

az provider register --namespace 'Microsoft.Web'

az provider show --namespace Microsoft.Web

az storage account create \
   --name $STORAGE_NAME \
   --resource-group $RESOURCE_GROUP_NAME \
   --encryption-services blob \
   --location $LOCATION \
   --sku Standard_ZRS

export FUNCTION_OUTPUT=$(az functionapp create \
    --name $FUNCTION_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --storage-account $STORAGE_NAME \
    --consumption-plan-location $LOCATION \
    --os-type linux \
    --runtime java \
    --runtime-version 17 \
    --functions-version 4  \
    --disable-app-insights)

export APP_SERVICE_PLAN_ID=$(echo "$FUNCTION_OUTPUT" | jq -r '.serverFarmId')

az functionapp plan show --ids $APP_SERVICE_PLAN_ID

az functionapp plan create \
   --name $APP_SERVICE_PLAN \
   --resource-group $RESOURCE_GROUP_NAME \
   --location $LOCATION \
   --sku B1 \
   --is-linux

az acr create \
   --name $REPO_NAME \
   --resource-group $RESOURCE_GROUP_NAME \
   --sku Basic \
   --admin-enabled true

az acr login --name $REPO_NAME

export TOKEN=$(az acr login --name $REPO_NAME --expose-token --output tsv --query accessToken)

docker login $REPO_NAME.azurecr.io \
   --username 00000000-0000-0000-0000-000000000000 \
   --password-stdin <<< $TOKEN

docker push $REPO_NAME.azurecr.io/gdk-function:latest

export ACR_CREDENTIALS=$(az acr credential show --name $REPO_NAME)

export ACR_USERNAME=$(echo "$ACR_CREDENTIALS" | jq -r '.username')
export ACR_PASSWORD=$(echo "$ACR_CREDENTIALS" | jq -r '.passwords[0].value')

az functionapp create \
   --name $FUNCTION_NAME_NATIVE \
   --resource-group $RESOURCE_GROUP_NAME \
   --storage-account $STORAGE_NAME \
   --os-type linux \
   --plan $APP_SERVICE_PLAN \
   --image $REPO_NAME.azurecr.io/gdk-function:latest \
   --registry-server $REPO_NAME.azurecr.io \
   --registry-username $ACR_USERNAME \
   --registry-password $ACR_PASSWORD \
   --functions-version 4 \
   --disable-app-insights