azure-gradle-plugins

• Compiling plugins locally
• Azure WebApp plugin
  • Running sample ToDo app
  • Common settings
  • Web App on Windows
    • Deploy WAR
    • Deploy JAR
  • Web App on Linux
  • Web Apps on Containers
    • Deployment from Private Container Registry (Azure Container Registry)
    • Deployment from public Docker Hub
    • Deployment from private Docker Hub
• Azure Functions plugin
  • Prerequisites
  • Common configuration
  • Tasks
  • Running sample Azure Functions app
• Azure Authentication settings

Compiling plugins locally

In build.gradle update reference to local maven repo. Then run

# Windows
gradlew.bat publishToMavenLocal

# Linux/macOS
./gradlew publishToMavenLocal

Azure WebApp plugin

plugins {
  id "lenala.azure.azurewebapp" version "1.0.1"
}

Common settings

These types of deployment are supported:

Web App on Windows

Deploy WAR

appService block should be specified, with the values:

azureWebApp {
    resourceGroup = "${System.env.WEBAPP_RESOURCE_GROUP}"
    appName = "${System.env.WEBAPP_NAME}"
    pricingTier = "S2"
    region = "southcentralus"

    appService = {
        type = 'windows'
        javaWebContainer = "tomcat 8.5"
        javaVersion = "1.8.0_102"
    }

    authentication = {
        type = "file"
        file = "<path_to_auth_file>"
    }

    deployment = {
        type = "war"
        // if 'warFile' is not specified, default output of the 'war' plugin will be used
        // warFile = '<path_to_war_file>'
        contextPath = 'todoapp'    // Url path. Optional, if not specified Web App will be deployed to root. Works for WAR deployment type only.
    }
}

Deploy JAR

appService block should be specified, with the values:

azureWebApp {
    resourceGroup = "${System.env.WEBAPP_RESOURCE_GROUP}"
    appName = "${System.env.WEBAPP_NAME}"
    pricingTier = "S1"
    appService = {
        type = 'windows'
        javaVersion = '1.8.0_25'
    }
    authentication = {
        type = "file"
        file = file('C:/stuff/2days.azureauth')
    }
    deployment = {
        type = "jar"
        // optional, if not provided, bootJar task output is used
        // jarFile = file('<path_to_jar_file>')
    }
}

Sample ToDo app

Web App on Linux

appService block should contain the values:

azureWebApp {
    resourceGroup = <resource_group>
    appName = <appName>
    pricingTier = "S2"
    appService = {
        type = 'linux'
        runtimeStack = 'TOMCAT 9.0-jre8'
    }
    authentication = {
        type = "file"
        file = "<path_to_auth_file>"
    }
    deployment = {
        type = "war"
        // if 'warFile' is not specified, default output of the 'war' plugin will be used
        // warFile = '<path_to_war_file>'
        contextPath = 'todoapp'
    }
}

Sample ToDo App

Web Apps on Containers

In samples/todo-app-on-azure folder, update reference to local maven repo, appName and Azure Container Registry url and credentials. Follow this tutorial to get started with Azure Container Registry.

In gradle.properties, set your container registry serverId, serverUsername, and serverPassword.

To push the Docker image, you'll need Docker running, then execute the dockerPushImage task:

# Windows
gradlew.bat dockerPushImage

# Linux/macOS
./gradlew dockerPushImage

Create a new CosmosDB instance and set your CosmosDB credentials in src/main/resources/application.properties.

Configure azurewebapp in build.gradle with valid values for resourceGroup, appName, pricingTier, and authFile (see the section on Azure Authentication settings).

Then deploy the ToDo web application to a Azure Container instance, you must specify the azureWebappDeploy task:

# Windows
gradlew.bat azureWebappDeploy

# Linux/macOS
./gradlew azureWebappDeploy

containerSettings block should be specified.

Deployment from Private Container Registry (Azure Container Registry)

    resourceGroup = <resource_group>
    appName = <appName>
    pricingTier = "S1"
    appService = {
        type = 'docker'
        imageName = dockerImage
        serverId = project.property('serverId')
        registryUrl = "https://" + serverId
        username = project.property('serverUsername')
        password = project.property('serverPassword')
    }

    authentication = {
        type = "file"
        file = "C:/stuff/my2.azureauth"
    }

    deployment = {
        type = "none"
    }
}

Usage example

Deployment from public Docker Hub

Deployment from private Docker Hub

Azure Functions plugin

plugins {
  id "lenala.azure.azurefunctions" version "1.0.1"
}

Prerequisites

Required only to run Azure Functions locally:

• Azure Functions Core Tools 2.0 and above

Common configuration

azurefunctions {
    authFile = <file_with_authentication_info>
}

Tasks

PackageTask

Package the functions for deployment.

task azureFunctionsPackage(type: PackageTask) {
    dependsOn jar
    appName = "myFunctionApp"
    resourceGroup = "myFunctionApp"
    region = "westus"
}

DeployTask

Deploy the project output jar to target Function App.

task azureFunctionsDeploy(type: DeployTask) {
    appName = "myFunctionApp"
    resourceGroup = "myFunctionApp"
    region = "westus"
}

RunTask

Invoke Azure Functions Local Emulator to run all functions.

task azureFunctionsRun(type: RunTask) {
    appName = "myFunctionApp"
    resourceGroup = "myFunctionApp"
    region = "westus"
}

AddTask

Create new Java function and add to current project.

task azureFunctionsAdd(type: AddTask) {
    functionPackageName = "my.function"
    functionTemplate = "HttpTrigger"
}

Running sample Azure Functions app

To build and deploy Azure Functions application, run:

gradle azureFunctionsPackage
gradle azureFunctionsDeploy

Where azureFunctionsPackage is of type DeployTask and AzureFunctionsDeploy of type DeployTask.

To verify function running, you can use curl -X POST -d "Azure World" <Deployed Host URL>/api/hello.

To add a new function, run:

gradle azureFunctionsAdd

Where azureFunctionsAdd is of type AddTask.

To run function locally, use:

gradle azureFunctionsRun

Where azureFunctionsRun is of type RunTask.

Source code for sample app

Azure Authentication settings

To authenticate with Azure, device login can be used. To enable that, you need to sign in with Azure CLI first. Alternatively, authentication file can be used. The authentication file, referenced as "my.azureauth" in the example, contains the information of a service principal. You can generate this file using Azure CLI 2.0 through the following command. Make sure you selected your subscription by az account set --subscription and you have the privileges to create service principals.

az ad sp create-for-rbac --sdk-auth > my.azureauth

Please see Authentication in Azure Management Libraries for Java for authentication file formats. You can configure to use authentication file in gradle build script:

azurewebapp {
    ...
    authFile=<path_to_file>
    ...
}

Another way to authenticate with Azure would be to provide settings in gradle.properties:

client=<client_id>
tenant=<tenant_id>
key=(need key or certificate info)
certificate=(optional)
certificatePassword=(optional)
environment=(optional)

subscriptionId can be also provided in gradle.properties, in case it is different from default subscription id.