How to deploy polyglot apps in Azure Spring Apps Enterprise tier

Article
01/18/2023
10 minutes to read

Note

Azure Spring Apps is the new name for the Azure Spring Cloud service. Although the service has a new name, you'll see the old name in some places for a while as we work to update assets such as screenshots, videos, and diagrams.

This article applies to: ❌ Basic/Standard tier ✔️ Enterprise tier

This article shows you how to deploy polyglot apps in Azure Spring Apps Enterprise tier, and how these polyglot apps can use the build service features provided by buildpacks.

Prerequisites

An already provisioned Azure Spring Apps Enterprise tier instance. For more information, see Quickstart: Build and deploy apps to Azure Spring Apps using the Enterprise tier.
Azure CLI, version 2.43.0 or higher.

Deploy a polyglot application

When you create an Enterprise tier instance of Azure Spring Apps, you'll be provided with a default builder with one of the following supported language family buildpacks:

These buildpacks support deployment from source code or artifact for Java, .NET Core, Go, web static files, Node.js, and Python apps. You can also create a custom builder by specifying buildpacks and stack. For more information, see the Manage custom builders section of Use Tanzu Build Service.

When deploying polyglot apps, you should choose a builder to build the app, as shown in the following example. If you don't specify the builder, a default builder will be used.

az spring app deploy \
    --name <app-name> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

If you deploy the app with an artifact file, use --artifact-path to specify the file path. Both JAR and WAR files are acceptable.

If the Azure CLI detects the WAR package as a thin JAR, use --disable-validation to disable validation.

If you deploy the source code folder to an active deployment, use --source-path to specify the folder, as shown in the following example:

az spring app deploy \
    --name <app-name> \
    --builder <builder-name> \
    --source-path <path-to-source-code>

You can also configure the build environment to build the app. For example, in a Java application, you can specify the JDK version using the BP_JVM_VERSION build environment.

To specify build environments, use --build-env, as shown in the following example. The available build environment variables are described later in this article.

az spring app deploy \
    --name <app-name> \
    --build-env <key1=value1> <key2=value2> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

Additionally, for each build, you can specify the build resources, as shown in the following example.

az spring app deploy \
    --name <app-name> \
    --build-env <key1=value1> <key2=value2> \
    --build-cpu <build-cpu-size> \
    --build-memory <build-memory-size> \
    --builder <builder-name> \
    --artifact-path <path-to-your-JAR-file>

The default build CPU/memory resource is 1 vCPU, 2 Gi. If your app needs a smaller or larger amount of memory, then use --build-memory to specify the memory resources; for example, 500Mi, 1Gi, 2Gi, and so on. If your app needs a smaller or larger amount of CPU resources, then use --build-cpu to specify the CPU resources; for example, 500m, 1, 2, and so on.

The CPU and memory resources are limited by the build service agent pool size. For more information, see the Build agent pool section of Use Tanzu Build Service. The sum of the processing build resource quota can't exceed the agent pool size.

The parallel number of build tasks depends on the agent pool size and each build resource. For example, if the build resource is the default 1 vCPU, 2 Gi and the agent pool size is 6 vCPU, 12 Gi, then the parallel build number is 6.

Other build tasks will be blocked for a while because of resource quota limitations.

Your application must listen on port 8080. Spring Boot applications will override the SERVER_PORT to use 8080 automatically.

The following table indicates the features supported for each language.

Feature	Java	Python	Node	.NET Core	Go	Static Files
App lifecycle management	✔️	✔️	✔️	✔️	✔️	✔️
Assign endpoint	✔️	✔️	✔️	✔️	✔️	✔️
Azure Monitor	✔️	✔️	✔️	✔️	✔️	✔️
Out of box APM integration	✔️	❌	❌	❌	❌	❌
Blue/green deployment	✔️	✔️	✔️	✔️	✔️	✔️
Custom domain	✔️	✔️	✔️	✔️	✔️	✔️
Scaling - auto scaling	✔️	✔️	✔️	✔️	✔️	✔️
Scaling - manual scaling (in/out, up/down)	✔️	✔️	✔️	✔️	✔️	✔️
Managed Identity	✔️	✔️	✔️	✔️	✔️	✔️
API portal for VMware Tanzu®	✔️	✔️	✔️	✔️	✔️	✔️
Spring Cloud Gateway for VMware Tanzu®	✔️	✔️	✔️	✔️	✔️	✔️
Application Configuration Service for VMware Tanzu®	✔️	❌	❌	❌	❌	❌
VMware Tanzu® Service Registry	✔️	❌	❌	❌	❌	❌
Virtual network	✔️	✔️	✔️	✔️	✔️	✔️
Outgoing IP Address	✔️	✔️	✔️	✔️	✔️	✔️
E2E TLS	✔️	✔️	✔️	✔️	✔️	✔️
Advanced troubleshooting - thread/heap/JFR dump	✔️	❌	❌	❌	❌	❌
Bring your own storage	✔️	✔️	✔️	✔️	✔️	✔️
Integrate service binding with Resource Connector	✔️	❌	❌	❌	❌	❌
Availability Zone	✔️	✔️	✔️	✔️	✔️	✔️
App Lifecycle events	✔️	✔️	✔️	✔️	✔️	✔️
Reduced app size - 0.5 vCPU and 512 MB	✔️	✔️	✔️	✔️	✔️	✔️
Automate app deployments with Terraform and Azure Pipeline Task	✔️	✔️	✔️	✔️	✔️	✔️
Soft Deletion	✔️	✔️	✔️	✔️	✔️	✔️
Interactive diagnostic experience (AppLens-based)	✔️	✔️	✔️	✔️	✔️	✔️
SLA	✔️	✔️	✔️	✔️	✔️	✔️

For more information about the supported configurations for different language apps, see the corresponding section later in this article.