Quickstart: Create a Java function in Azure from the command line

In this article, you use command-line tools to create a Java function that responds to HTTP requests. After testing the code locally, you deploy it to the serverless environment of Azure Functions.

If Maven isn't your preferred development tool, check out our similar tutorials for Java developers:

• Gradle
• IntelliJ IDEA
• Visual Studio Code

Completing this quickstart incurs a small cost of a few USD cents or less in your Azure account.

Configure your local environment

Before you begin, you must have the following:

• An Azure account with an active subscription. Create an account for free.

• The Azure CLI version 2.4 or later.

• The Java Developer Kit, version 8, 11, 17, 21(Linux only). The JAVA_HOME environment variable must be set to the install location of the correct version of the JDK.

• Apache Maven, version 3.0 or above.

Install the Azure Functions Core Tools

The recommended way to install Core Tools depends on the operating system of your local development computer.

Create a local function project

In Azure Functions, a function project is a container for one or more individual functions that each responds to a specific trigger. All functions in a project share the same local and hosting configurations. In this section, you create a function project that contains a single function.

1. In an empty folder, run the following command to generate the Functions project from a Maven archetype.

   • Bash
   • PowerShell
   • Cmd

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

   Important

   • Use -DjavaVersion=11 if you want your functions to run on Java 11. To learn more, see Java versions.
   • The JAVA_HOME environment variable must be set to the install location of the correct version of the JDK to complete this article.

2. Maven asks you for values needed to finish generating the project on deployment.
   Provide the following values when prompted:

   Prompt	Value	Description
   groupId	com.fabrikam	A value that uniquely identifies your project across all projects, following the package naming rules for Java.
   artifactId	fabrikam-functions	A value that is the name of the jar, without a version number.
   version	1.0-SNAPSHOT	Choose the default value.
   package	com.fabrikam	A value that is the Java package for the generated function code. Use the default.

3. Type Y or press Enter to confirm.

   Maven creates the project files in a new folder with a name of artifactId, which in this example is fabrikam-functions.

4. Navigate into the project folder:

   cd fabrikam-functions
   

   This folder contains various files for the project, including configurations files named local.settings.json and host.json. Because local.settings.json can contain secrets downloaded from Azure, the file is excluded from source control by default in the .gitignore file.

(Optional) Examine the file contents

If desired, you can skip to Run the function locally and examine the file contents later.

Function.java

Function.java contains a run method that receives request data in the request variable is an HttpRequestMessage that's decorated with the HttpTrigger annotation, which defines the trigger behavior.

package com.fabrikam;

import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;

import java.util.Optional;

/**
 * Azure Functions with HTTP Trigger.
 */
public class Function {
    /**
     * This function listens at endpoint "/api/HttpExample". Two ways to invoke it using "curl" command in bash:
     * 1. curl -d "HTTP Body" {your host}/api/HttpExample
     * 2. curl "{your host}/api/HttpExample?name=HTTP%20Query"
     */
    @FunctionName("HttpExample")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET, HttpMethod.POST},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        // Parse query parameter
        final String query = request.getQueryParameters().get("name");
        final 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 {
            return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
        }
    }
}

The response message is generated by the HttpResponseMessage.Builder API.

pom.xml

Settings for the Azure resources created to host your app are defined in the configuration element of the plugin with a groupId of com.microsoft.azure in the generated pom.xml file. For example, the configuration element below instructs a Maven-based deployment to create a function app in the java-functions-group resource group in the westus region. The function app itself runs on Windows hosted in the java-functions-app-service-plan plan, which by default is a serverless Consumption plan.

<plugin>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-functions-maven-plugin</artifactId>
    <version>${azure.functions.maven.plugin.version}</version>
    <configuration>
        <!-- function app name -->
        <appName>${functionAppName}</appName>
        <!-- function app resource group -->
        <resourceGroup>java-functions-group</resourceGroup>
        <!-- function app service plan name -->
        <appServicePlanName>java-functions-app-service-plan</appServicePlanName>
        <!-- function app region-->
        <!-- refers https://github.com/microsoft/azure-maven-plugins/wiki/Azure-Functions:-Configuration-Details#supported-regions for all valid values -->
        <region>westus</region>
        <!-- function pricingTier, default to be consumption if not specified -->
        <!-- refers https://github.com/microsoft/azure-maven-plugins/wiki/Azure-Functions:-Configuration-Details#supported-pricing-tiers for all valid values -->
        <!-- <pricingTier></pricingTier> -->
        <!-- Whether to disable application insights, default is false -->
        <!-- refers https://github.com/microsoft/azure-maven-plugins/wiki/Azure-Functions:-Configuration-Details for all valid configurations for application insights-->
        <!-- <disableAppInsights></disableAppInsights> -->
        <runtime>
            <!-- runtime os, could be windows, linux or docker-->
            <os>windows</os>
            <javaVersion>8</javaVersion>
        </runtime>
        <appSettings>
            <property>
                <name>FUNCTIONS_EXTENSION_VERSION</name>
                <value>~4</value>
            </property>
        </appSettings>
    </configuration>
    <executions>
        <execution>
            <id>package-functions</id>
            <goals>
                <goal>package</goal>
            </goals>
        </execution>
    </executions>
</plugin>

You can change these settings to control how resources are created in Azure, such as by changing runtime.os from windows to linux before initial deployment. For a complete list of settings supported by the Maven plug-in, see the configuration details.

FunctionTest.java

The archetype also generates a unit test for your function. When you change your function to add bindings or add new functions to the project, you'll also need to modify the tests in the FunctionTest.java file.

Run the function locally

1. Run your function by starting the local Azure Functions runtime host from the LocalFunctionProj folder:

   mvn clean package
   mvn azure-functions:run
   

   Toward the end of the output, the following lines should appear:

    ...
   
    Now listening on: http://0.0.0.0:7071
    Application started. Press Ctrl+C to shut down.
   
    Http Functions:
   
            HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
    ...
   
    

   Note

   If HttpExample doesn't appear as shown above, you likely started the host from outside the root folder of the project. In that case, use Ctrl+C to stop the host, navigate to the project's root folder, and run the previous command again.

2. Copy the URL of your HttpExample function from this output to a browser and append the query string ?name=<YOUR_NAME>, making the full URL like http://localhost:7071/api/HttpExample?name=Functions. The browser should display a message that echoes back your query string value. The terminal in which you started your project also shows log output as you make requests.

3. When you're done, use Ctrl+C and choose y to stop the functions host.

Deploy the function project to Azure

A function app and related resources are created in Azure when you first deploy your functions project. Settings for the Azure resources created to host your app are defined in the pom.xml file. In this article, you'll accept the defaults.

1. Before you can deploy, sign in to your Azure subscription using either Azure CLI or Azure PowerShell.

   • Azure CLI
   • Azure PowerShell

   az login
   

   The az login command signs you into your Azure account.

2. Use the following command to deploy your project to a new function app.

   mvn azure-functions:deploy
   

   This creates the following resources in Azure:

   • Resource group. Named as java-functions-group.
   • Storage account. Required by Functions. The name is generated randomly based on Storage account name requirements.
   • Hosting plan. Serverless hosting for your function app in the westus region. The name is java-functions-app-service-plan.
   • Function app. A function app is the deployment and execution unit for your functions. The name is randomly generated based on your artifactId, appended with a randomly generated number.

   The deployment packages the project files and deploys them to the new function app using zip deployment. The code runs from the deployment package in Azure.

Invoke the function on Azure

Because your function uses an HTTP trigger, you invoke it by making an HTTP request to its URL in the browser or with a tool like curl.

Run the following command to view near real-time streaming logs:

func azure functionapp logstream <APP_NAME> 

In a separate terminal window or in the browser, call the remote function again. A verbose log of the function execution in Azure is shown in the terminal.

Clean up resources

If you continue to the next step and add an Azure Storage queue output binding, keep all your resources in place as you'll build on what you've already done.

Otherwise, use the following command to delete the resource group and all its contained resources to avoid incurring further costs.

az group delete --name java-functions-group

Remove-AzResourceGroup -Name java-functions-group

Next steps