Tell us about your PDF experience.

Azure SDK for Java documentation

Cloud development using Java on Azure.

Azure for Java developers

ｂ GET STARTED

Get started with Apache Maven

Get started with Gradle

Get started with IntelliJ or Eclipse

Use the Azure SDK for Java

ｉ REFERENCE

Libraries, drivers, and Spring modules

Java API browser

ｃ HOW-TO GUIDE

Identity and authentication

Configure logging

Common concepts

ｄ TRAINING

HTTP clients and pipeline

Asynchronous programming

Pagination and iteration

Long-running operations

Proxying

Tracing
Get started with Azure SDK and Apache
Maven
Article • 02/14/2025

This article shows you how to use Apache Maven to build applications with the Azure
SDK for Java. In this article, you set up a new project with Maven, build projects with
Maven, and use the GraalVM native image tooling to create platform-specific native
binaries.

The Azure SDK for Java project includes a Maven archetype that can accelerate the
bootstrapping of a new project. The Azure SDK for Java Maven archetype creates a new
application, with files and a directory structure that follows best practices. In particular,
the Azure SDK for Java Maven archetype creates a new Maven project with the following
features:

A dependency on the latest azure-sdk-bom BOM release, which ensures that all
dependencies for Azure SDK for Java are aligned, and gives you the best developer
experience possible.
Built-in support for GraalVM native image compilation.
Support for generating a new project with a specified set of Azure SDK for Java
client libraries.
Integration with the Azure SDK for Java build tooling, which gives build-time
analysis of your project to ensure that many best practices are followed.

Prerequisites
Java Developer Kit, version 8 or later. We recommend version 17 for the best
experience.
Apache Maven

Create a new Maven project

The Azure SDK for Java Maven archetype is published to Maven Central. That means you
can use the archetype directly to bootstrap a new application with the following
command:

Bash

mvn archetype:generate \
-DarchetypeGroupId=com.azure.tools \
 -DarchetypeArtifactId=azure-sdk-archetype

After you enter this command, a series of prompts asks for details about your project so
the archetype can generate the right output for you. The following table describes the
properties you need to provide values for:

ﾉ Expand table

Name Description

groupId (Required) The Maven groupId to use in the POM file created for the generated
project.

artifactId (Required) The Maven artifactId to use in the POM file created for the
generated project.

package (Optional) The package name to put the generated code into. Inferred from the
groupId if it's not specified.

azureLibraries (Optional) A comma-separated list of Azure SDK for Java libraries, using their
Maven artifact IDs. For a list of such artifact IDs, see Azure SDK Releases .

enableGraalVM (Optional) false to indicate that the generated Maven POM file shouldn't
include support for compiling your application to a native image using
GraalVM; otherwise, true . The default value is true .

javaVersion (Optional) The minimum version of the JDK to target when building the
generated project, such as 8 , 11 , or 17 . The default value is the latest LTS
release (currently 17 ). The minimum value is 8 .

junitVersion (Optional) The version of JUnit to include as a dependency. The default value is
5 . Valid values 4 and 5 .

Alternately, you can provide these values when you call the archetype command shown
earlier. This approach is useful, for example, for automation purposes. You can specify
the values as parameters using the standard Maven syntax of appending -D to the
parameter name, for example:

Bash

-DjavaVersion=17

Java version support

As a best practice, you should use a Java LTS release when deploying to production. By
default, the Azure SDK Maven archetype selects the latest LTS release, which currently
sets a Java 17 baseline. However, you can override the default behavior by setting the
javaVersion parameter.

Use the Azure SDK for Java build tool

The Azure SDK for Java project ships a Maven build tool that you can include in your
projects. This tool runs locally and doesn't transmit any data to Microsoft. You can
configure the tool to generate a report or fail the build when certain conditions are met,
which is useful to ensure compliance with numerous best practices, such as the
following practices:

Validation of the correct use of the azure-sdk-for-java BOM, including using the
latest version, and relying on it to define dependency versions on Azure SDK for
Java client libraries. For more information, see the Add Azure SDK for Java to an
existing project section.
Validation that historical Azure client libraries aren't being used when newer and
improved versions exist.

The report also provides insight into usage of beta APIs.

You can configure the build tool in a project Maven POM file as shown in the following
example. Be sure to replace the {latest_version} placeholder with the latest version
listed online .

XML

<build>
<plugins>
<plugin>
<groupId>com.azure.tools</groupId>
<artifactId>azure-sdk-build-tool</artifactId>
<version>{latest_version}</version>
</plugin>
</plugins>
</build>

After adding the build tool into a Maven project, you can run the tool by calling mvn
compile azure:run . Depending on the configuration provided, you can expect to see

build failures or report files generated that can inform you about potential issues before
they become more serious. We recommend that you run this tool as part of your CI/CD
pipeline. As the build tool evolves, we'll publish new releases, and we recommend that
developers frequently check for new releases and update as appropriate.
It's possible to configure the build tool to enable or disable particular features. For this
configuration, add a configuration section in the XML shown previously. Within that
section, configure the settings shown in the following table. Any configuration that isn't
explicitly mentioned takes the default value specified in the table.

ﾉ Expand table

Property name Default Description

value

validateAzureSdkBomUsed true Ensures that the project has the azure-

sdk-for-java BOM referenced
appropriately, so that Azure SDK for Java
client library dependencies may take
their versions from the BOM.

validateLatestBomVersionUsed true Ensures that dependencies are kept up

to date by reporting back (or failing the
build) if a newer azure-sdk-for-java BOM
exists. You can always find the latest
version online .

validateBomVersionsAreUsed true Ensures that, where a dependency is

available from the azure-sdk-for-java
BOM, the version isn't being manually
overridden.

validateNoDeprecatedMicrosoftLibraryUsed true Ensures that the project doesn't make

use of previous-generation Azure
libraries. Using the new and previous-
generation libraries in a single project is
unlikely to cause any issue, but results in
a suboptimal developer experience.

validateNoBetaLibraryUsed false Some Azure SDK for Java client libraries

have beta releases, with version strings
in the form x.y.z-beta.n . Enabling this
feature ensures that no beta libraries are
being used.

validateNoBetaApiUsed true Azure SDK for Java client libraries

sometimes have GA releases with
methods annotated with @Beta . This
check looks to see if any such methods
are being used.

sendToMicrosoft true Specifies whether to send the build

report to Microsoft for telemetry
purposes. This helps guide the
 Property name Default Description
value

development team on where to prioritize

documentation, samples, and improved
convenience APIs. No user-identifiable
content is submitted.

reportFile - (Optional) Specifies the location to write

the build report out to, in JSON format. If
not specified, no report is written, and a
summary of the build, or the appropriate
build failures, is shown in the terminal.

Add Azure SDK for Java to an existing project

To make dependency version management simpler, the Azure SDK for Java team
publishes the Azure SDK for Java client BOM each month. This BOM file includes all
Generally Available (GA) Azure SDK for Java client packages with their compatible
dependency version.

To use dependency versions for an Azure SDK for Java client library that is in the BOM,
include the following snippet in the project pom.xml file. Replace the
{bom_version_to_target} placeholder with the latest release of the Azure SDK for Java

BOM . Replace the {artifactId} placeholder with the Azure service SDK package
name.

XML

<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-sdk-bom</artifactId>
<version>{bom_version_to_target}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>{artifactId}</artifactId>
</dependency>
</dependencies>
You can find all releases of the Azure SDK for Java client BOM at azure-sdk-bom . We
recommend using the latest version to take advantage of the newest features of the
Azure SDK for Java client libraries.

Using Maven to define project dependencies can make managing your projects simpler.
With the Azure SDK BOM and Azure SDK Maven archetype, you can accelerate your
project while being more confident about your dependency versioning over the long
term. We recommend using the BOM to keep dependencies aligned and up to date.

In addition to adding the Azure SDK BOM, we recommend also including the Azure SDK
for Java build tool. This tool helps to diagnose many issues commonly encountered
when building applications, as described previously in this article.

Include a package not in the BOM

The Azure SDK for Java client BOM includes only Generally Available (GA) libraries. If you
want to depend on a package that is still in beta or on a library version different than
the one included in the BOM, you can specify the Maven dependency version along with
the groupId and artifactId in the dependency section. You can choose to have
dependencies that use BOM versions and dependencies with overridden versions in the
same project POM file, as shown in the following example:

XML

<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-messaging-eventhubs</artifactId> <!-- Use the
dependency version that is in the BOM -->
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-messaging-servicebus</artifactId>
<version>7.4.0</version> <!-- Override the Service Bus dependency
version specified in the BOM -->
</dependency>
</dependencies>

If you use this approach and specify versions directly in your project, you might get
dependency version conflicts. These conflicts arise because different packages may
depend on different versions of common dependencies, and these versions may not be
compatible with each other. When conflicts occur, you can experience undesirable
behavior at compile time or runtime. We recommend that you rely on versions that are
in the Azure SDK BOM unless necessary. For more information on dealing with
dependencies when using the Azure SDK for Java, see Troubleshoot dependency version
conflicts.

Build a native image with GraalVM

You can use GraalVM to create a native image of a Java application. GraalVM compiles
the Java code ahead of time into native machine code, which can yield drastic
performance gains in certain situations. The Azure SDK for Java provides the necessary
metadata in each of its client libraries to support GraalVM native image compilation.

To get started, you need to install GraalVM and prepare your development system for
compiling native images. The installation process for GraalVM is straightforward, and the
GraalVM documentation provides step-by-step instructions for installing GraalVM and
using GraalVM to install native-image . Follow the prerequisites section carefully to
install the necessary native compilers for your operating system.

The Azure SDK for Java Maven archetype can configure your build to support GraalVM
native image compilation, but you can also add it to an existing Maven build. You can
find instructions for Maven on the GraalVM website.

Next, you're ready to run a native image build. You can use standard Maven tooling to
use GraalVM native image. For Maven, use the following command:

shell

mvn clean package -Pnative

After you run this command, GraalVM outputs a native executable for the platform it's
running on. The executable appears in the Maven /target directory of your project. You
can now run your application with this executable file, and it should perform similarly to
a standard Java application.

Next steps
Get started with Azure extensions for IntelliJ and Eclipse

Feedback
Was this page helpful?  Yes  No
Provide product feedback | Get help at Microsoft Q&A
Get started with Azure SDK and Gradle
Article • 02/14/2025

This article shows you how to use Gradle to build applications with the Azure SDK for
Java. In this article, you set up a new project with Gradle, build projects with Gradle, and
use the GraalVM native image tooling to create platform-specific native binaries.

Prerequisites
Java Developer Kit, version 8 or later. We recommend version 17 for the best
experience.
Gradle

Create a new Gradle project

Unlike Maven, Gradle doesn't have an archetype system for bootstrapping projects in a
template fashion. Bootstrapping a Gradle project is possible, but it doesn't configure
Azure SDK for Java specifics like the Maven equivalent. To work through the steps, first
use the following command to create a new, empty directory from the command line:

Bash

gradle init --type java-application

You're prompted to answer a short series of questions, after which you have a directory
containing a collection of files and subdirectories. To ensure that the generated files
compile, run the following commands required to verify the build:

Bash

gradle clean assemble test

You can now move on to editing the build.gradle file located in the app directory. For
starters, to make dependency version management simpler, the Azure SDK for Java
team publishes the Azure SDK for Java client BOM each month. This BOM file includes
all Generally Available (GA) Azure SDK for Java client packages with their compatible
dependency version.

To use dependency versions for an Azure SDK for Java client library that is in the BOM,
include the following snippet in the project build.gradle file. Replace the
{bom_version_to_target} placeholder with the latest release of the Azure SDK for Java

BOM .

groovy

dependencies {
implementation platform('com.azure:azure-sdk-bom:
{bom_version_to_target}')
}

You can find all releases of the Azure SDK for Java client BOM at azure-sdk-bom . We
recommend using the latest version to take advantage of the newest features of the
Azure SDK for Java client libraries.

Once you've started depending on the Azure SDK for Java BOM, you can include
dependencies on libraries without specifying their version. These version values are
looked up automatically in the Azure SDK for Java BOM. For example, to include an
azure-storage-blob dependency, add the following lines to your build.gradle file:

groovy

dependencies {
implementation 'com.azure:azure-storage-blob'
}

Using Gradle to define project dependencies can make managing your projects simpler.
With the Azure SDK BOM, you can accelerate your project while being more confident
about your dependency versioning over the long term. We recommend using the BOM
to keep dependencies aligned and up to date.

Include a package not in the BOM

The Azure SDK for Java client BOM includes only Generally Available (GA) libraries. If you
want to depend on a package that is still in beta or on a library version different than
the one included in the BOM, you can specify the Maven dependency version along with
the groupId and artifactId in the dependency section. You can choose to have
dependencies that use BOM versions and dependencies with overridden versions in the
same project POM file, as shown in the following example:

groovy

dependencies {
// Use the dependency version that is in the BOM
implementation 'com.azure:azure-messaging-eventhubs'
 // Override the Service Bus dependency version specified in the BOM
implementation 'com.azure:azure-messaging-servicebus:7.4.0'
}

If you use this approach and specify versions directly in your project, you might get
dependency version conflicts. These conflicts arise because different packages may
depend on different versions of common dependencies, and these versions may not be
compatible with each other. When conflicts occur, you can experience undesirable
behavior at compile time or runtime. We recommend that you rely on versions that are
in the Azure SDK BOM unless necessary. For more information on dealing with
dependencies when using the Azure SDK for Java, see Troubleshoot dependency version
conflicts.

Build a native image with GraalVM

You can use GraalVM to create a native image of a Java application. GraalVM compiles
the Java code ahead of time into native machine code, which can yield drastic
performance gains in certain situations. The Azure SDK for Java provides the necessary
metadata in each of its client libraries to support GraalVM native image compilation.

To get started, you need to install GraalVM and prepare your development system for
compiling native images. The installation process for GraalVM is straightforward, and the
GraalVM documentation provides step-by-step instructions for installing GraalVM and
using GraalVM to install native-image . Follow the prerequisites section carefully to
install the necessary native compilers for your operating system.

With your existing Gradle-based project, you can follow the GraalVM instructions for
Gradle on how to add GraalVM support to your project. In doing so, you then have
more build options, allowing you to compile your application into the standard Java
bytecode, or into a native image compiled by GraalVM.

Next, you're ready to run a native image build. You can use standard Gradle tooling to
use GraalVM native image. For Gradle, use the following command:

Bash

gradle nativeCompile

After you run this command, GraalVM outputs a native executable for the platform it's
running on. The executable appears in the Gradle /app/build/native/nativeCompile
directory of your project. You can now run your application with this executable file, and
it should perform similarly to a standard Java application.

Next steps
Get started with Azure extensions for IntelliJ and Eclipse

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Get started with Azure extensions for
IntelliJ and Eclipse
Article • 04/01/2025

This article walks you through setting up a development environment for Azure
development in Java. Microsoft provides IDE extensions for both IntelliJ and Eclipse to
increase productivity when working with the Azure SDK for Java.

Install the Azure Toolkit for IntelliJ

The Azure toolkit is necessary if you plan to deploy web apps or APIs programmatically.
The toolkit also has a comprehensive SDK reference book embedded for any Azure
development with Java SDK. For a quickstart with Azure Web Apps, see Create a Hello
World web app for Azure App Service using IntelliJ.

The following steps summarize the installation process.

1. Select the File menu, and then select Settings.

2. Select Browse repositories, and then search Azure and install the Azure toolkit for
Intellij.

3. Restart Intellij.

4. Open reference book from Tools -> Azure -> Azure SDK Reference Book
Install the Azure Toolkit for Eclipse
The Azure toolkit is necessary if you plan to deploy web apps or APIs programmatically.
Currently, it isn't used for any other kinds of development. For a quickstart, see Create a
Hello World web app for Azure App Service using Eclipse.

The following steps summarize the installation process.

1. Select the Help menu, and then select Install new software.
2. In the Work with box, enter http://dl.microsoft.com/eclipse/ and select Enter.
3. Select the check box next to Azure toolkit for Java. Clear the check box for
Contact all update sites during install to find required software. Then select Next.

Next steps
Create a Hello World web app for Azure App Service using IntelliJ
Create a Hello World web app for Azure App Service using Eclipse

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Java libraries, drivers, and Spring modules
for Azure
06/02/2025

This article provides links to the Java libraries, drivers, Spring modules, and related articles
available for use with Azure.

Microsoft’s goal is to empower every developer to achieve more, and our commitment to Java
developers is no exception. Java and Spring developers want to use idiomatic libraries to
simplify connections to their preferred cloud services. These libraries, drivers, and modules let
you easily interact with Azure services across data, messaging, cache, storage, eventing,
directory, and secrets management. Use the following table to find the right library, driver, or
module and guides to get started.

ﾉ Expand table

Category Azure Java library or Java getting Spring Spring getting

service driver started module started

Data SQL SQL Database Use Java and JDBC Spring Data: Use Spring Data
database JDBC driver with Azure SQL • JDBC with Azure SQL
Database • JPA Database:
• R2DBC • JDBC
• JPA
• R2DBC

Data MySQL MySQL JDBC Quickstart: Use Java Spring Data: Use Spring Data
driver and JDBC with • JDBC with Azure
Azure Database for • JPA Database for
MySQL • R2DBC MySQL:
• JDBC
• JPA
• R2DBC

Data PostgreSQL PostgreSQL Quickstart: Use Java Spring Data: Use Spring Data
JDBC driver and JDBC with • JDBC with Azure
Azure Database for • JPA Database for
PostgreSQL Flexible • R2DBC PostgreSQL:
Server • JDBC
• JPA
• R2DBC
Category Azure Java library or Java getting Spring Spring getting
service driver started module started

Data MariaDB MariaDB driver MariaDB drivers Spring Data: Use Spring Data
and management • JDBC with Azure
tools compatible • JPA Database for
with Azure • R2DBC MySQL:
Database for • JDBC
MariaDB • JPA
• R2DBC

Data Azure Maven Quickstart: Build a Spring Data How to use the
Cosmos DB - Repository: Java app to Azure Cosmos Spring Boot
SQL com.azure » manage Azure DB Starter with Azure
azure-cosmos Cosmos DB for Cosmos DB for
NoSQL data NoSQL

Data Azure MongoDB Java Quickstart: Create a Spring Data How to use
Cosmos DB - Drivers console app with MongoDB Spring Data with
MongoDB Java and Azure Azure Cosmos DB
Cosmos DB for for MongoDB
MongoDB

Data Azure Datastax Java Quickstart: Build a Spring Data How to use
Cosmos DB - Driver for Java app to Apache Spring Data with
Cassandra Apache manage Azure Cassandra Azure Cosmos DB
Cassandra Cosmos DB for for Apache
Apache Cassandra Cassandra
data (v4 Driver)

Data Azure Gremlin Java Quickstart: Build a Quickstart: Build

Cosmos DB Driver graph database a graph database
for Apache with the Java SDK with the Java SDK
Gremlin and Azure Cosmos and Azure
DB for Apache Cosmos DB for
Gremlin Apache Gremlin

Cache Redis JEDIS client Quickstart: Use • Spring Data Configure a

Azure Cache for Redis Spring Boot
Redis in Java • Reference Initializer app to
• Spring Cloud use Redis in the
Azure Redis cloud with Azure
support Redis Cache

Cache Redis LETTUCE client Best Practices for • Spring Data Configure a
using Azure Cache Redis Spring Boot
for Redis with • Reference Initializer app to
Lettuce • Spring Cloud use Redis in the
Azure Redis cloud with Azure
support Redis Cache
Category Azure Java library or Java getting Spring Spring getting
service driver started module started

Storage Azure Maven Quickstart: Manage Spring Cloud How to use the
Storage Repository: blobs with Java v12 Azure resource Spring Boot
com.azure » SDK handing Starter for Azure
azure-storage- Storage
blob

Messaging Service Bus JMS + AMQP Send messages to • Spring How to use
an Azure Service AMQP Spring Boot
Bus topic and • Spring Cloud Starter for Azure
receive messages Azure JMS Service Bus JMS
from subscriptions support
to the topic

Messaging Service Bus Azure Service Azure Service Bus • Spring How to use
Bus client Samples client AMQP Spring Cloud
library for Java library for Java • Spring Azure Stream
integration Binder for Azure
with Azure Service Bus
Service Bus
• Spring Cloud
Stream Binder
for Azure
Service Bus

Eventing Event Hubs Kafka Send and Receive • Spring for How to use the
Messages in Java Apache Spring Boot
using Azure Event Kafka Starter for
Hubs for Apache • Spring Cloud Apache Kafka
Kafka Ecosystems Azure Kafka with Azure Event
support Hubs

Eventing Event Hubs Azure Event Use Java to send Spring Cloud How to create a
Hubs libraries events to or receive Stream Binder Spring Cloud
for Java events from Azure for Event Hubs Stream Binder
Event Hubs application with
Azure Event Hubs

Directory Microsoft MSAL Enable Java Servlet Microsoft Enable Spring

Entra ID apps to sign in Entra Spring Boot Web apps
users on Microsoft Boot Starter to sign in users
Entra ID on Microsoft
Entra ID

Directory Azure Active MSAL Enable Java Servlet Azure AD B2C Enable Spring
Directory apps to sign in Spring Boot Boot Web apps
B2C users on Azure AD Starter to sign in users
B2C on Azure AD B2C
 Category Azure Java library or Java getting Spring Spring getting
service driver started module started

Secrets Key Vault Key Vault Manage secrets Key Vault Manage secrets
Secrets using Key Vault Secrets Spring for Spring Boot
Boot Starter apps

Certificates Key Vault Key Vault Key Vault Manage

Certificates JCA Certificates certificates for
Spring Boot Spring Boot apps
Starter

Next steps
For all other libraries, see Azure SDK for Java libraries.
Use the Azure SDK for Java
Article • 04/02/2025

The open-source Azure SDK for Java simplifies provisioning, managing, and using Azure
resources from Java application code.

Important details
The Azure libraries are how you communicate with Azure services from Java code
that you run either locally or in the cloud.
The libraries support Java 8 and later, and are tested against both the Java 8
baseline and the latest Java 'long-term support' release.
The libraries include full Java module support, which means that they're fully
compliant with the requirements of a Java module and export all relevant packages
for use.
The Azure SDK for Java is composed solely of many individual Java libraries that
relate to specific Azure services. There are no other tools in the "SDK".
There are distinct "management" and "client" libraries (sometimes referred to as
"management plane" and "data plane" libraries). Each set serves different purposes
and is used by different kinds of code. For more information, see the following
sections later in this article:
Connect to and use Azure resources with client libraries.
Provision and manage Azure resources with management libraries.
You can find documentation for the libraries in the Azure for Java Reference
organized by Azure Service, or the Java API browser organized by package name.

Other details
The Azure SDK for Java libraries build on top of the underlying Azure REST API,
allowing you to use those APIs through familiar Java paradigms. However, you can
always use the REST API directly from Java code, if you prefer.
You can find the source code for the Azure libraries in the GitHub repository . As
an open-source project, contributions are welcome!
We're currently updating the Azure SDK for Java libraries to share common cloud
patterns such as authentication protocols, logging, tracing, transport protocols,
buffered responses, and retries.
This shared functionality is contained in the azure-core library.
For more information on the guidelines we apply to the libraries, see the Java
Azure SDK Design Guidelines .
Supported platforms for Azure SDK for Java
The Azure SDK for Java ships with support for Java 8 and later, but we recommend that
developers always use the latest Java long-term support (LTS) release in development
and when releasing to production. Using the latest LTS release ensures the availability of
the latest improvements within Java, including bug fixes, performance improvements,
and security fixes. Also, the Azure SDK for Java includes additional support for later
releases of Java. This additional support improves performance and includes JDK-
specific enhancements beyond the supported Java 8 baseline.

The Azure SDK for Java is tested and supported on Windows, Linux, and macOS. It is not
tested on other platforms that the JDK supports, and does not support Android
deployments. For developers wanting to develop software for deployment on Android
devices and which make use of Azure services, there are Android-specific libraries
available in the Azure SDK for Android project.

Connect to and use Azure resources with client

libraries
The client (or "data plane") libraries help you write Java application code to interact with
already-provisioned services. Client libraries exist only for those services that support a
client API. You can identify them because their Maven group ID is com.azure .

All Azure Java client libraries follow the same API design pattern of offering a Java
builder class that's responsible for creating an instance of a client. This pattern separates
the definition and instantiation of the client from its operation, allowing the client to be
immutable and therefore easier to use. Additionally, all client libraries follow a few
important patterns:

Client libraries that support both synchronous and asynchronous APIs must offer
these APIs in separate classes. What this means is that in these cases there would
be, for example, a KeyVaultClient for sync APIs and a KeyVaultAsyncClient for
async APIs.

There's a single builder class that takes responsibility for building both the sync
and async APIs. The builder is named similarly to the sync client class, with Builder
included. For example, KeyVaultClientBuilder . This builder has buildClient() and
buildAsyncClient() methods to create client instances, as appropriate.

Because of these conventions, all classes ending in Client are immutable and provide
operations to interact with an Azure service. All classes that end in ClientBuilder
provide operations to configure and create an instance of a particular client type.

Client libraries example

The following code example shows how to create a synchronous Key Vault KeyClient :

Java

KeyClient client = new KeyClientBuilder()

.endpoint(<your Key Vault URL>)
.credential(new DefaultAzureCredentialBuilder().build())
.buildClient();

The following code example shows how to create an asynchronous Key Vault
KeyAsyncClient :

Java

KeyAsyncClient client = new KeyClientBuilder()

.endpoint(<your Key Vault URL>)
.credential(new DefaultAzureCredentialBuilder().build())
.buildAsyncClient();

For more information on working with each client library, see the README.md file
located in the library's project directory in the SDK GitHub repository . You can also
find more code snippets in the reference documentation and the Azure Samples.

Provision and manage Azure resources with

management libraries
The management (or "management plane") libraries help you create, provision and
otherwise manage Azure resources from Java application code. You can find these
libraries in the com.azure.resourcemanager Maven group ID. All Azure services have
corresponding management libraries.

With the management libraries, you can write configuration and deployment scripts to
perform the same tasks that you can through the Azure portal or the Azure CLI.

All Azure Java management libraries provide a *Manager class as service API, for
example, ComputeManager for Azure compute service, or AzureResourceManager for the
aggregation of popular services.
Management libraries example
The following code example shows how to create a ComputeManager :

Java

ComputeManager computeManager = ComputeManager

.authenticate(
new DefaultAzureCredentialBuilder().build(),
new AzureProfile(AzureEnvironment.AZURE));

The following code example shows how to provision a new virtual machine:

Java

VirtualMachine virtualMachine = computeManager.virtualMachines()

.define(<your virtual machine>)
.withRegion(Region.US_WEST)
.withExistingResourceGroup(<your resource group>)
.withNewPrimaryNetwork("10.0.0.0/28")
.withPrimaryPrivateIPAddressDynamic()
.withoutPrimaryPublicIPAddress()

.withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_18_04_LTS
)
.withRootUsername(<virtual-machine username>)
.withSsh(<virtual-machine SSH key>)
.create();

The following code example shows how to get an existing virtual machine:

Java

VirtualMachine virtualMachine = computeManager.virtualMachines()

.getByResourceGroup(<your resource group>, <your virtual machine>);

The following code example shows how to update the virtual machine and add a new
data disk:

Java

virtualMachine.update()
.withNewDataDisk(10)
.apply();

For more information on working with each management library, see the README.md
file located in the library's project directory in the SDK GitHub repository . You can also
find more code snippets in the reference documentation and the Azure Samples.

Get help and connect with the SDK team

Visit the Azure SDK for Java documentation .
Post questions to the community on Stack Overflow .
Open issues against the SDK in the GitHub repository .
Mention @AzureSDK on Twitter.

Next steps
Now that you understand what the Azure SDK for Java is, you can take a deep dive into
many of the cross-cutting concepts that exist to make you productive when using the
libraries. The following articles provide good starting points:

HTTP clients and pipelines

Asynchronous programming
Pagination and iteration
Long-running operations
Configure proxies
Configure tracing

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure authentication with Java and
Azure Identity
Article • 04/01/2025

This article provides an overview of the Azure Identity library for Java, which provides
Microsoft Entra token authentication support across the Azure SDK for Java. This library
provides a set of TokenCredential implementations that you can use to construct Azure
SDK clients that support Microsoft Entra token authentication.

The Azure Identity library currently supports:

Azure authentication in Java development environments, which enables:

IDEA IntelliJ authentication, with the sign-in information retrieved from the
Azure Toolkit for IntelliJ.
Azure CLI authentication, with the sign-in information saved in the Azure CLI
Azure Developer CLI authentication, with the sign-in information saved in the
Azure Developer CLI
Azure PowerShell authentication, with the sign-in information saved in Azure
PowerShell
Authenticating applications hosted in Azure, which enables:
DefaultAzureCredential authentication

Managed Identity authentication

Authentication with service principals, which enables:
Client Secret authentication
Client Certificate authentication
Authentication with user credentials, which enables:
Interactive browser authentication
Device code authentication
Username/password authentication

Follow these links to learn more about the specifics of each of these authentication
approaches. In the rest of this article, we introduce the commonly used
DefaultAzureCredential and related subjects.

Add the Maven dependencies

Include the azure-sdk-bom in your project to take a dependency on the stable version of
the library. In the following snippet, replace the {bom_version_to_target} placeholder
with the version number. To learn more about the BOM, see the Add Azure SDK for Java
to an existing project section of Get started with Azure SDK and Apache Maven.

XML

<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-sdk-bom</artifactId>
<version>{bom_version_to_target}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

Then include the direct dependency in the dependencies section without the version tag:

XML

<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
</dependency>
</dependencies>

Key concepts
There are two key concepts in understanding the Azure Identity library: the concept of a
credential, and the most common implementation of that credential,
DefaultAzureCredential .

A credential is a class that contains or can obtain the data needed for a service client to
authenticate requests. Service clients across the Azure SDK accept credentials when
they're constructed, and service clients use those credentials to authenticate requests to
the service.

The Azure Identity library focuses on OAuth authentication with Microsoft Entra ID, and
it offers various credential classes that can acquire a Microsoft Entra token to
authenticate service requests. All of the credential classes in this library are
implementations of the TokenCredential abstract class in azure-core , and you can use
any of them to construct service clients that can authenticate with a TokenCredential .
DefaultAzureCredential is appropriate for most scenarios where the application is

intended to ultimately run in the Azure Cloud. DefaultAzureCredential combines

credentials that are commonly used to authenticate when deployed, with credentials
that are used to authenticate in a development environment. For more information,
including examples using DefaultAzureCredential , see the DefaultAzureCredential
section of Authenticating Azure-hosted Java applications.

Examples
As noted in Use the Azure SDK for Java, the management libraries differ slightly. One of
the ways they differ is that there are libraries for consuming Azure services, called client
libraries, and libraries for managing Azure services, called management libraries. In the
following sections, there's a quick overview of authenticating in both client and
management libraries.

Authenticate Azure client libraries

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using DefaultAzureCredential .

Java

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(new DefaultAzureCredentialBuilder().build())
.buildClient();

Authenticate Azure management libraries

The Azure management libraries use the same credential APIs as the Azure client
libraries, but also require an Azure subscription ID to manage the Azure resources on
that subscription.

You can find the subscription IDs on the Subscriptions page in the Azure portal .
Alternatively, use the following Azure CLI command to get subscription IDs:

Azure CLI

az account list --output table

You can set the subscription ID in the AZURE_SUBSCRIPTION_ID environment variable.
AzureProfile picks up this ID as the default subscription ID during the creation of a

Manager instance in the following example:

Java

AzureResourceManager azureResourceManager =
AzureResourceManager.authenticate(
new DefaultAzureCredentialBuilder().build(),
new AzureProfile(AzureEnvironment.AZURE))
.withDefaultSubscription();

DefaultAzureCredential used in this example authenticates an AzureResourceManager

instance using DefaultAzureCredential . You can also use other Token Credential
implementations offered in the Azure Identity library in place of
DefaultAzureCredential .

Troubleshooting
For guidance, see Troubleshoot Azure Identity authentication issues.

Next steps
This article introduced the Azure Identity functionality available in the Azure SDK for
Java. It described DefaultAzureCredential as common and appropriate in many cases.
The following articles describe other ways to authenticate using the Azure Identity
library, and provide more information about DefaultAzureCredential :

Azure authentication in development environments

Authenticating applications hosted in Azure
Authentication with service principals
Authentication with user credentials

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Authenticate Azure-hosted Java
applications
Article • 10/18/2024

This article looks at how the Azure Identity library supports Microsoft Entra token
authentication for applications hosted on Azure. This support is made possible through
a set of TokenCredential implementations, which are discussed in this article.

This article covers the following subjects:

DefaultAzureCredential
ManagedIdentityCredential

For troubleshooting authentication issues related to Azure-hosted applications, see

Troubleshoot Azure-hosted application authentication.

DefaultAzureCredential
DefaultAzureCredential combines credentials that are commonly used to authenticate

when deployed, with credentials that are used to authenticate in a development

environment. For more information, see DefaultAzureCredential overview.

Configure DefaultAzureCredential
DefaultAzureCredential supports a set of configurations through setters on the

DefaultAzureCredentialBuilder or environment variables.

Setting the environment variables AZURE_CLIENT_ID , AZURE_CLIENT_SECRET , and

AZURE_TENANT_ID as defined in Environment variables configures

DefaultAzureCredential to authenticate as the service principal specified by the

values.
Setting .managedIdentityClientId(String) on the builder or the environment
variable AZURE_CLIENT_ID configures DefaultAzureCredential to authenticate as a
user-assigned managed identity, while leaving them empty configures it to
authenticate as a system-assigned managed identity.
Setting .tenantId(String) on the builder or the environment variable
AZURE_TENANT_ID configures DefaultAzureCredential to authenticate to a specific

tenant for either the shared token cache or IntelliJ IDEA.

 Setting the environment variable AZURE_USERNAME configures
DefaultAzureCredential to pick the corresponding cached token from the shared

token cache.

Authenticate with DefaultAzureCredential

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using DefaultAzureCredential :

Java

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<KEY_VAULT_NAME>.vault.azure.net")
.credential(new DefaultAzureCredentialBuilder().build())
.buildClient();

Authenticate a user-assigned managed identity with

DefaultAzureCredential
The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using DefaultAzureCredential deployed to an
Azure resource with a user-assigned managed identity configured.

Java

/**
* DefaultAzureCredential uses the user-assigned managed identity with the
specified client ID.
*/
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
.managedIdentityClientId("<CLIENT_ID>")
.build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<KEY_VAULT_NAME>.vault.azure.net")
.credential(credential)
.buildClient();

ManagedIdentityCredential
ManagedIdentityCredential authenticates the managed identity (system-assigned or
user-assigned) of an Azure resource. So, if the application is running inside an Azure
resource that supports managed identity through IDENTITY/MSI , IMDS endpoints, or
both, then this credential gets your application authenticated, and offers a secretless
authentication experience.

For more information, see What are managed identities for Azure resources?.

Authenticate in Azure with managed identity

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the ManagedIdentityCredential in a
Virtual Machine, App Service, Functions app, Cloud Shell, Service Fabric, Arc, or AKS
environment on Azure, with system-assigned or user-assigned managed identity
enabled.

Java

/**
* Authenticate with a user-assigned managed identity.
*/
ManagedIdentityCredential credential = new
ManagedIdentityCredentialBuilder()
.clientId("<CLIENT_ID>") // required only for user-assigned
.build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<KEY_VAULT_NAME>.vault.azure.net")
.credential(credential)
.buildClient();

Environment variables
You can configure DefaultAzureCredential and EnvironmentCredential with
environment variables. Each type of authentication requires values for specific variables:

Service principal with secret

ﾉ Expand table

Variable name Value

AZURE_CLIENT_ID ID of a Microsoft Entra application.

AZURE_TENANT_ID ID of the application's Microsoft Entra tenant.

 Variable name Value

AZURE_CLIENT_SECRET One of the application's client secrets.

Service principal with certificate

ﾉ Expand table

Variable name Value

AZURE_CLIENT_ID ID of a Microsoft Entra application.

AZURE_TENANT_ID ID of the application's Microsoft Entra tenant.

AZURE_CLIENT_CERTIFICATE_PATH Path to a PEM-encoded certificate file including private

key (without password protection).

AZURE_CLIENT_CERTIFICATE_PASSWORD (optional) Password of the certificate file, if any.

AZURE_CLIENT_SEND_CERTIFICATE_CHAIN (optional) Send certificate chain in x5c header to support

subject name / issuer-based authentication.

Username and password

ﾉ Expand table

Variable name Value

AZURE_CLIENT_ID ID of a Microsoft Entra application.

AZURE_TENANT_ID ID of the application's Microsoft Entra tenant.

AZURE_USERNAME A username (usually an email address).

AZURE_PASSWORD The associated password for the given username.

Configuration is attempted in this order. For example, if values for a client secret and
certificate are both present, the client secret is used.

Next steps
This article covered authentication for applications hosted in Azure. This form of
authentication is one of multiple ways you can authenticate in the Azure SDK for Java.
The following articles describe other ways:
 Azure authentication in development environments
Authentication with service principals
Authentication with user credentials

If you run into issues related to Azure-hosted application authentication, see

Troubleshoot Azure-hosted application authentication.

After you've mastered authentication, see Configure logging in the Azure SDK for Java
for information on the logging functionality provided by the SDK.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure authentication in Java
development environments
Article • 10/18/2024

This article provides an overview of the Azure Identity library support for Microsoft Entra
token authentication. This support enables authentication for applications running
locally on developer machines through a set of TokenCredential implementations.

This article covers the following subjects:

Device code credential

Interactive browser credential
Azure CLI credential
IntelliJ credential

For troubleshooting development environment authentication issues, see Troubleshoot

development environment authentication.

Device code credential

The device code credential interactively authenticates a user on devices with limited UI.
It works by prompting the user to visit a sign-in URL on a browser-enabled machine
when the application attempts to authenticate. The user then enters the device code
mentioned in the instructions along with their sign-in credentials. Upon successful
authentication, the application that requested authentication gets authenticated
successfully on the device it's running on.

For more information, see Microsoft identity platform and the OAuth 2.0 device
authorization grant flow.

Enable applications for device code flow

To authenticate a user through device code flow, do the following steps:

1. Go to Microsoft Entra ID in the Azure portal and find your app registration.
2. Navigate to the Authentication section.
3. Under Suggested Redirected URIs, check the URI that ends with
/common/oauth2/nativeclient .

4. Under Default Client Type, select yes for Treat application as a public client.
These steps enable the application to authenticate, but it still doesn't have permission to
sign you into Microsoft Entra ID, or access resources on your behalf. To address this
issue, navigate to API Permissions, and enable Microsoft Graph and the resources you
want to access.

You must also be the admin of your tenant to grant consent to your application when
you sign in for the first time.

If you can't configure the device code flow option on your Microsoft Entra ID, then it
may require your app to be multi- tenant. To make your app multi-tenant, navigate to
the Authentication panel, then select Accounts in any organizational directory. Then,
select yes for Treat application as Public Client.

Authenticate a user account with device code flow

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the DeviceCodeCredential on an IoT
device.

Java

DeviceCodeCredential deviceCodeCredential = new

DeviceCodeCredentialBuilder()
.challengeConsumer(challenge -> {
// lets user know of the challenge
System.out.println(challenge.getMessage());
}).build();

// Azure SDK client builders accept the credential as a parameter

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(deviceCodeCredential)
.buildClient();

Interactive browser credential

This credential interactively authenticates a user with the default system browser and
offers a smooth authentication experience by letting you use your own credentials to
authenticate your application.

Enable applications for interactive browser OAuth 2 flow

To use InteractiveBrowserCredential , you need to register an application in Microsoft
Entra ID with permissions to sign in on behalf of a user. Follow the earlier steps for
device code flow to register your application. As mentioned previously, an admin of
your tenant must grant consent to your application before any user account can sign in.

You may notice that in InteractiveBrowserCredentialBuilder , a redirect URL is required.

Add the redirect URL to the Redirect URIs subsection under the Authentication section
of your registered Microsoft Entra application.

Authenticate a user account interactively in the browser

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the InteractiveBrowserCredential .

Java

InteractiveBrowserCredential interactiveBrowserCredential = new

InteractiveBrowserCredentialBuilder()
.clientId("<your client ID>")
.redirectUrl("http://localhost:8765")
.build();

// Azure SDK client builders accept the credential as a parameter

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(interactiveBrowserCredential)
.buildClient();

Azure CLI credential

The Azure CLI credential authenticates in a development environment with the enabled
user or service principal in Azure CLI. It uses the Azure CLI given a user that is already
signed into it, and uses the CLI to authenticate the application against Microsoft Entra
ID.

Sign in Azure CLI for AzureCliCredential

Sign in as a user with the following Azure CLI command:

Azure CLI

az login
Sign in as a service principal using the following command:

Azure CLI

az login \
--service-principal \
--username <client-ID> \
--password <client-secret> \
--tenant <tenant-ID>

If the account or service principal has access to multiple tenants, make sure the desired
tenant or subscription is in the state "Enabled" in the output from the following
command:

Azure CLI

az account list

Before you use AzureCliCredential in code, run the following command to verify that
the account has been successfully configured.

Azure CLI

az account get-access-token

You may need to repeat this process after a certain time period, depending on the
refresh token validity in your organization. Generally, the refresh token validity period is
a few weeks to a few months. AzureCliCredential prompts you to sign in again.

Authenticate a user account with Azure CLI

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the AzureCliCredential on a workstation
with Azure CLI installed and signed in.

Java

AzureCliCredential cliCredential = new AzureCliCredentialBuilder().build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(cliCredential)
.buildClient();
IntelliJ credential
The IntelliJ credential authenticates in a development environment with the account in
Azure Toolkit for IntelliJ. It uses the signed-in user information on the IntelliJ IDE and
uses it to authenticate the application against Microsoft Entra ID.

Sign in Azure Toolkit for IntelliJ for IntelliJCredential

Use the following steps to sign in:

1. In your IntelliJ window, open File > Settings > Plugins.

2. Search for "Azure Toolkit for IntelliJ" in the marketplace. Install and restart IDE.
3. Find the new menu item Tools > Azure > Azure Sign In
4. Device Login helps you sign in as a user account. Follow the instructions to sign in
on the login.microsoftonline.com website with the device code. IntelliJ prompts
you to select your subscriptions. Select the subscription with the resources that
you want to access.

Authenticate a user account with IntelliJ IDEA

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the IntelliJCredential on a workstation
where IntelliJ IDEA is installed, and the user has signed in with an Azure account to the
Azure Toolkit for IntelliJ.

Java

IntelliJCredential intelliJCredential = new IntelliJCredentialBuilder()

.build();

// Azure SDK client builders accept the credential as a parameter

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(intelliJCredential)
.buildClient();

Next steps
This article covered authentication during development using credentials available on
your computer. This form of authentication is one of multiple ways you can authenticate
in the Azure SDK for Java. The following articles describe other ways:
 Authenticating applications hosted in Azure
Authentication with service principals
Authentication with user credentials

If you run into issues related to development environment authentication, see

Troubleshoot development environment authentication.

After you've mastered authentication, see Configure logging in the Azure SDK for Java
for information on the logging functionality provided by the SDK.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure authentication with service
principal
Article • 04/01/2025

This article looks at how the Azure Identity library supports Microsoft Entra token
authentication via service principal. This article covers the following subjects:

Create a service principal with the Azure CLI

Client secret credential
Client certificate credential

For more information, see Application and service principal objects in Microsoft Entra ID.
For troubleshooting service principal authentication issues, see Troubleshoot service
principal authentication.

Create a service principal with the Azure CLI

Use the following Azure CLI examples to create or get client secret credentials.

Use the following command to create a service principal and configure its access to
Azure resources:

Azure CLI

az ad sp create-for-rbac \
--name <your application name> \
--role Contributor \
--scopes /subscriptions/mySubscriptionID

This command returns a value similar to the following output:

Output

{
"appId": "generated-app-ID",
"displayName": "dummy-app-name",
"name": "http://dummy-app-name",
"password": "random-password",
"tenant": "tenant-ID"
}

Use the following command to create a service principal along with a certificate. Note
down the path/location of this certificate.
 Azure CLI

az ad sp create-for-rbac \
--name <your application name> \
--role Contributor \
--cert <certificate name> \
--create-cert

Check the returned credentials and to note down the following information:

AZURE\_CLIENT\_ID for the appId.

AZURE\_CLIENT\_SECRET for the password.

AZURE\_TENANT\_ID for the tenant.

Client secret credential

This credential authenticates the created service principal through its client secret
(password). This example demonstrates authenticating the SecretClient from the
azure-security-keyvault-secrets client library using the ClientSecretCredential .

Java

/**
* Authenticate with client secret.
*/
ClientSecretCredential clientSecretCredential = new
ClientSecretCredentialBuilder()
.clientId("<your client ID>")
.clientSecret("<your client secret>")
.tenantId("<your tenant ID>")
.build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(clientSecretCredential)
.buildClient();

Client certificate credential

This credential authenticates the created service principal through its client certificate.
This example demonstrates authenticating the SecretClient from the azure-security-
keyvault-secrets client library using the ClientCertificateCredential .

Java
 /**
* Authenticate with a client certificate.
*/
ClientCertificateCredential clientCertificateCredential = new
ClientCertificateCredentialBuilder()
.clientId("<your client ID>")
.pemCertificate("<path to PEM certificate>")
// Choose between either a PEM certificate or a PFX certificate.
//.pfxCertificate("<path to PFX certificate>")
//.clientCertificatePassword("PFX CERTIFICATE PASSWORD")
.tenantId("<your tenant ID>")
.build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(clientCertificateCredential)
.buildClient();

Next steps
This article covered authentication via service principal. This form of authentication is
one of multiple ways you can authenticate in the Azure SDK for Java. The following
articles describe other ways:

Azure authentication in development environments

Authenticating applications hosted in Azure
Authentication with User Credentials

If you run into issues related to service principal authentication, see Troubleshoot service
principal authentication.

After you've mastered authentication, see Configure logging in the Azure SDK for Java
for information on the logging functionality provided by the SDK.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure authentication with user
credentials
Article • 03/26/2025

This article looks at how the Azure Identity library supports Microsoft Entra token
authentication with user-provided credentials. This support is made possible through a
set of TokenCredential implementations discussed in this article.

This article covers the following subjects:

Device code credential

Interactive browser credential

Device code credential

The device code credential interactively authenticates a user on devices with limited UI.
It works by prompting the user to visit a sign-in URL on a browser-enabled machine
when the application attempts to authenticate. The user then enters the device code
mentioned in the instructions along with their sign-in credentials. Upon successful
authentication, the application that requested authentication gets authenticated
successfully on the device it's running on.

For more information, see Microsoft identity platform and the OAuth 2.0 device
authorization grant flow.

Enable applications for device code flow

To authenticate a user through device code flow, use the following steps:

1. Go to Microsoft Entra ID in Azure portal and find your app registration.

2. Navigate to the Authentication section.
3. Under Suggested Redirected URIs, check the URI that ends with
/common/oauth2/nativeclient .

4. Under Default Client Type, select yes for Treat application as a public client .

These steps enable the application to authenticate, but it still doesn't have permission to
sign you into Microsoft Entra ID, or access resources on your behalf. To address this
issue, navigate to API Permissions, and enable Microsoft Graph and the resources you
want to access, such as Key Vault.
You also need to be the admin of your tenant to grant consent to your application when
you sign in for the first time.

If you can't configure the device code flow option on your Microsoft Entra ID, then it
may require your app to be multi- tenant. To make your app multi-tenant, navigate to
the Authentication panel, then select Accounts in any organizational directory. Then,
select yes for Treat application as Public Client.

Authenticate a user account with device code flow

The following example demonstrates authenticating the SecretClient from the Azure
Key Vault Secret client library for Java using the DeviceCodeCredential on an IoT
device.

Java

/**
* Authenticate with device code credential.
*/
DeviceCodeCredential deviceCodeCredential = new
DeviceCodeCredentialBuilder()
.challengeConsumer(challenge -> {
// Lets the user know about the challenge.
System.out.println(challenge.getMessage());
}).build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(deviceCodeCredential)
.buildClient();

Interactive browser credential

This credential interactively authenticates a user with the default system browser and
offers a smooth authentication experience by letting you use your own credentials to
authenticate your application.

Enable applications for interactive browser OAuth 2 flow

To use InteractiveBrowserCredential , you need to register an application in Microsoft
Entra ID with permissions to sign in on behalf of a user. Follow the previous steps for
device code flow to register your application. As mentioned previously, an admin of
your tenant must grant consent to your application before any user account can sign in.
You may notice in InteractiveBrowserCredentialBuilder , a redirect URL is required. Add
the redirect URL to the Redirect URIs subsection under the Authentication section of
your registered Microsoft Entra application.

Authenticate a user account interactively in the browser

The following example demonstrates authenticating the SecretClient from the azure-
security-keyvault-secrets client library using the InteractiveBrowserCredential .

Java

/**
* Authenticate interactively in the browser.
*/
InteractiveBrowserCredential interactiveBrowserCredential = new
InteractiveBrowserCredentialBuilder()
.clientId("<your app client ID>")
.redirectUrl("YOUR_APP_REGISTERED_REDIRECT_URL")
.build();

// Azure SDK client builders accept the credential as a parameter.

SecretClient client = new SecretClientBuilder()
.vaultUrl("https://<your Key Vault name>.vault.azure.net")
.credential(interactiveBrowserCredential)
.buildClient();

Next steps
This article covered authentication with user credentials. This form of authentication is
one of multiple ways you can authenticate in the Azure SDK for Java. The following
articles describe other ways:

Azure authentication in development environments

Authenticating applications hosted in Azure
Authentication with service principals

After you've mastered authentication, see Configure logging in the Azure SDK for Java
for information on the logging functionality provided by the SDK.

Feedback
Was this page helpful?  Yes  No
Provide product feedback | Get help at Microsoft Q&A
Credential chains in the Azure Identity
library for Java
06/03/2025

The Azure Identity library provides credentials—public classes that implement the Azure Core
library's TokenCredential interface. A credential represents a distinct authentication flow for
acquiring an access token from Microsoft Entra ID. These credentials can be chained together
to form an ordered sequence of authentication mechanisms to be attempted.

How a chained credential works

At runtime, a credential chain attempts to authenticate using the sequence's first credential. If
that credential fails to acquire an access token, the next credential in the sequence is
attempted, and so on, until an access token is successfully obtained. The following sequence
diagram illustrates this behavior:

Java app Credential chain TokenCredential instance

Authenticate to Microsoft Entra ID

1

getToken
2

loop [Traverse
TokenCredential
collection until
AccessToken received]

Fetch token
3

getToken
4

break [when Result is

AccessToken]

Result
5

AccessToken
6

Java app Credential chain TokenCredential instance

Why use credential chains
A chained credential can offer the following benefits:

Environment awareness: Automatically selects the most appropriate credential based on

the environment in which the app is running. Without it, you'd have to write code like
this:

Java

import com.azure.core.credential.TokenCredential;
import com.azure.identity.AzureCliCredentialBuilder;
import com.azure.identity.ManagedIdentityCredentialBuilder;

// Code omitted for brevity

TokenCredential credential = null;

// Set up credential based on environment (Azure or local development)

String environment = System.getenv("ENV");

if (environment != null && environment.equals("production")) {

credential = new ManagedIdentityCredentialBuilder()
.clientId(userAssignedClientId)
.build();
} else {
credential = new AzureCliCredentialBuilder()
.build();
}

Seamless transitions: Your app can move from local development to your staging or
production environment without changing authentication code.

Improved resiliency: Includes a fallback mechanism that moves to the next credential
when the prior fails to acquire an access token.

How to choose a chained credential

There are two disparate philosophies to credential chaining:

Use a preconfigured chain: Start with an opinionated, preconstructed chain that

accommodates the most common authentication scenarios. For this approach, see the
DefaultAzureCredential overview section.
"Build up" a chain: Start with an empty chain and include only what you need. For this
approach, see the ChainedTokenCredential overview section.
DefaultAzureCredential overview
DefaultAzureCredential is an opinionated, preconfigured chain of credentials. It's designed to
support many environments, along with the most common authentication flows and developer
tools. In graphical form, the underlying chain looks like this:

CREDENTIALS

Environment Workload Identity Managed Identity Shared Token Cache IntelliJ Azure CLI Azure PowerShell Azure Developer CLI

CREDENTIAL TYPES

Deployed service Developer tool 

The order in which DefaultAzureCredential attempts credentials follows.

ﾉ Expand table

Order Credential Description

1 Environment Reads a collection of environment variables to determine if an application

service principal (application user) is configured for the app. If so,
DefaultAzureCredential uses these values to authenticate the app to Azure. This
method is most often used in server environments but can also be used when
developing locally.

2 Workload If the app is deployed to an Azure host with Workload Identity enabled,
Identity authenticate that account.

3 Managed If the app is deployed to an Azure host with Managed Identity enabled,
Identity authenticate the app to Azure using that Managed Identity.

4 Shared Token If the developer authenticated to Azure by logging into Visual Studio,
Cache authenticate the app to Azure using that same account. (Windows only.)

5 IntelliJ If the developer authenticated via Azure Toolkit for IntelliJ, authenticate that
account.

6 Azure CLI If the developer authenticated to Azure using Azure CLI's az login command,
authenticate the app to Azure using that same account.

7 Azure If the developer authenticated to Azure using Azure PowerShell's Connect-

PowerShell AzAccount cmdlet, authenticate the app to Azure using that same account.

8 Azure If the developer authenticated to Azure using Azure Developer CLI's azd auth
Developer CLI login command, authenticate with that account.

In its simplest form, you can use the parameterless version of DefaultAzureCredential as
follows:
 Java

import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;

// Code omitted for brevity

DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()

.build();

How to customize DefaultAzureCredential

To exclude all Developer tool or Deployed service credentials, set environment variable
AZURE_TOKEN_CREDENTIALS to prod or dev , respectively. When a value of prod is used, the

underlying credential chain looks as follows:

Environment Workload Identity Managed Identity

When a value of dev is used, the chain looks as follows:

Shared Token Cache IntelliJ Azure CLI Azure PowerShell Azure Developer CLI

） Important

The AZURE_TOKEN_CREDENTIALS environment variable is supported in azure-identity

package versions 1.16.1 and later.

ChainedTokenCredential overview
ChainedTokenCredential is an empty chain to which you add credentials to suit your app's
needs. For example:

Java

import com.azure.identity.AzureCliCredential;
import com.azure.identity.AzureCliCredentialBuilder;
import com.azure.identity.ChainedTokenCredential;
import com.azure.identity.ChainedTokenCredentialBuilder;
import com.azure.identity.IntelliJCredential;
import com.azure.identity.IntelliJCredentialBuilder;
 // Code omitted for brevity

AzureCliCredential cliCredential = new AzureCliCredentialBuilder()

.build();
IntelliJCredential ijCredential = new IntelliJCredentialBuilder()
.build();

ChainedTokenCredential credential = new ChainedTokenCredentialBuilder()

.addLast(cliCredential)
.addLast(ijCredential)
.build();

The preceding code sample creates a tailored credential chain comprised of two development-
time credentials. AzureCliCredential is attempted first, followed by IntelliJCredential , if
necessary. In graphical form, the chain looks like this:

IntelliJ Azure CLI

 Tip

For improved performance, optimize credential ordering in ChainedTokenCredential from

most to least used credential.

Usage guidance for DefaultAzureCredential

DefaultAzureCredential is undoubtedly the easiest way to get started with the Azure Identity

library, but with that convenience comes tradeoffs. Once you deploy your app to Azure, you
should understand the app's authentication requirements. For that reason, replace
DefaultAzureCredential with a specific TokenCredential implementation, such as
ManagedIdentityCredential .

Here's why:

Debugging challenges: When authentication fails, it can be challenging to debug and

identify the offending credential. You must enable logging to see the progression from
one credential to the next and the success/failure status of each. For more information,
see Debug a chained credential.
 Performance overhead: The process of sequentially trying multiple credentials can
introduce performance overhead. For example, when running on a local development
machine, managed identity is unavailable. Consequently, ManagedIdentityCredential
always fails in the local development environment.
Unpredictable behavior: DefaultAzureCredential checks for the presence of certain
environment variables . It's possible that someone could add or modify these
environment variables at the system level on the host machine. Those changes apply
globally and therefore alter the behavior of DefaultAzureCredential at runtime in any app
running on that machine.

Debug a chained credential

To diagnose an unexpected issue or to understand what a chained credential is doing, enable
logging in your app.

For illustration purposes, assume the parameterless form of DefaultAzureCredential is used to

authenticate a request to a Blob Storage account. The app runs in the local development
environment, and the developer authenticated to Azure using the Azure CLI. When the app is
run, the following pertinent entries appear in the output:

Output

[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>

Attempted credential EnvironmentCredential is unavailable.
[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>
Attempted credential WorkloadIdentityCredential is unavailable.
[ForkJoinPool.commonPool-worker-1] WARN
com.microsoft.aad.msal4j.ConfidentialClientApplication - [Correlation ID:
aaaa0000-bb11-2222-33cc-444444dddddd] Execution of class
com.microsoft.aad.msal4j.AcquireTokenByClientCredentialSupplier failed:
java.util.concurrent.ExecutionException:
com.azure.identity.CredentialUnavailableException: ManagedIdentityCredential
authentication unavailable. Connection to IMDS endpoint cannot be established.
[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>
Attempted credential ManagedIdentityCredential is unavailable.
[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>
Attempted credential SharedTokenCacheCredential is unavailable.
[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>
Attempted credential IntelliJCredential is unavailable.
[main] INFO com.azure.identity.ChainedTokenCredential - Azure Identity =>
Attempted credential AzureCliCredential returns a token

In the preceding output, notice that:

EnvironmentCredential , WorkloadIdentityCredential , ManagedIdentityCredential ,

SharedTokenCacheCredential , and IntelliJCredential each failed to acquire a Microsoft

Entra access token, in that order.
The AzureCliCredential.getToken call succeeds, as indicated by the returns a token -
suffixed entry. Since AzureCliCredential succeeded, no credentials beyond it were tried.
Configure logging in the Azure SDK for
Java
Article • 04/01/2025

This article provides an overview of how to enable logging in applications that make use
of the Azure SDK for Java. The Azure client libraries for Java have two logging options:

A built-in logging framework for temporary debugging purposes.

Support for logging using the SLF4J interface.

We recommend that you use SLF4J because it's well known in the Java ecosystem and
it's well documented. For more information, see the SLF4J user manual .

This article links to other articles that cover many of the popular Java logging
frameworks. These other articles provide configuration examples, and describe how the
Azure client libraries can use the logging frameworks.

Whatever logging configuration you use, the same log output is available in either case
because all logging output in the Azure client libraries for Java is routed through an
azure-core ClientLogger abstraction.

The rest of this article details the configuration of all available logging options.

Enable HTTP request/response logging

HTTP request and response logging are off by default. You can configure clients that
communicate to Azure services over HTTP to write a log record for each request and
response (or exception) they receive.

If you use OpenTelemetry, consider using distributed tracing instead of logging for HTTP
requests. For more information, see Configure tracing in the Azure SDK for Java.

Configure HTTP logging with an environment variable

You can use the AZURE_HTTP_LOG_DETAIL_LEVEL environment variable to enable HTTP logs
globally. This variable supports the following values:

NONE : HTTP logs are disabled. This value is the default.

BASIC : HTTP logs contain request method, sanitized request URL, try count,

response code, and the content length for request and response bodies.
 HEADERS : HTTP logs include all the basic details and also include headers that are

known to be safe for logging purposes - that is, they don't contain secrets or
sensitive information. The full list of header names is available in the
HttpLogOptions class.
BODY_AND_HEADERS : HTTP logs include all the details provided by the HEADERS level

and also include request and response bodies as long as they're smaller than 16 KB
and printable.

７ Note

The request URL is sanitized - that is, all query parameter values are redacted
except for the api-version value. Individual client libraries may add other query
parameters that are known to be safe to the allowlist.

For example, the Azure Blob Storage shared access signature (SAS) URL is logged in the
following format: https://myaccount.blob.core.windows.net/pictures/profile.jpg?
sv=REDACTED&st=REDACTED&se=REDACTED&sr=REDACTED&sp=REDACTED&rscd=REDACTED&rsct=REDA

CTED&sig=REDACTED

２ Warning

Logging request and response bodies isn't recommended in production because

they might contain sensitive information, significantly affect performance, change
how content is buffered, and have other side effects.

Configure HTTP logging in code

Azure client builders that implement the HttpTrait<T> interface support code-based
HTTP logging configuration. Code-based configuration applies to individual client
instances and provides more options and customizations compared to environment
variable configuration.

To configure logs, pass an instance of HttpLogOptions to the httpLogOptions method

on the corresponding client builder. The following code shows an example for the App
Configuration service:

Java

HttpLogOptions httpLogOptions = new HttpLogOptions()

.setLogLevel(HttpLogDetailLevel.HEADERS)
.addAllowedHeaderName("Accept-Ranges")
 .addAllowedQueryParamName("label");

ConfigurationClient configurationClient = new ConfigurationClientBuilder()

.httpLogOptions(httpLogOptions)
...
.buildClient();

This code enables HTTP logs with headers and adds the Accept-Ranges response header
and the label query parameter to the corresponding allowlists. After this change, these
values should appear in the produced logs.

For the full list of configuration options, see the HttpLogOptions documentation.

Default logger (for temporary debugging)

As noted, all Azure client libraries use SLF4J for logging, but there's a fallback, default
logger built into Azure client libraries for Java. This default logger is provided for cases
where an application is deployed, and logging is required, but it's not possible to
redeploy the application with an SLF4J logger included. To enable this logger, you must
first be certain that no SLF4J logger exists (because it takes precedence), and then set
the AZURE_LOG_LEVEL environment variable. The following table shows the values allowed
for this environment variable:

ﾉ Expand table

Log Level Allowed environment variable values

VERBOSE verbose , debug

INFORMATIONAL info , information , informational

WARNING warn , warning

ERROR err , error

After the environment variable is set, restart the application to enable the environment
variable to take effect. This logger logs to the console, and doesn't provide the
advanced customization capabilities of an SLF4J implementation, such as rollover and
logging to file. To turn the logging off again, just remove the environment variable and
restart the application.

SLF4J logging
By default, you should configure logging using an SLF4J-supported logging framework.
First, include a relevant SLF4J logging implementation as a dependency from your
project. For more information, see Declaring project dependencies for logging in the
SLF4J user manual. Next, configure your logger to work as necessary in your
environment, such as setting log levels, configuring which classes do and don't log, and
so on. Some examples are provided through the links in this article, but for more
information, see the documentation for your chosen logging framework.

Log format
Logging frameworks support custom log message formatting and layouts. We
recommend including at least following fields to make it possible to troubleshoot Azure
client libraries:

Date and time with millisecond precision

Log severity
Logger name
Thread name
Message

For examples, see the documentation for the logging framework you use.

Structured logging
In addition to logging the common properties mentioned earlier, Azure client libraries
annotate log messages with extra context when applicable. For example, you might see
JSON-formatted logs containing az.sdk.message with context written as other root
properties, as shown in the following example:

log

16:58:51.038 INFO c.a.c.c.i.C.getManifestProperties -

{"az.sdk.message":"HTTP request","method":"GET","url":"
<>","tryCount":"1","contentLength":0}
16:58:51.141 INFO c.a.c.c.i.C.getManifestProperties -
{"az.sdk.message":"HTTP
response","contentLength":"558","statusCode":200,"url":"
<>","durationMs":102}

When you send logs to Azure Monitor, you can use the Kusto query language to parse
them. The following query provides an example:

Kusto
 traces
| where message startswith "{\"az.sdk.message"
| project timestamp, logger=customDimensions["LoggerName"],
level=customDimensions["LoggingLevel"],
thread=customDimensions["ThreadName"], azSdkContext=parse_json(message)
| evaluate bag_unpack(azSdkContext)

７ Note

Azure client library logs are intended for ad-hoc debugging. We don't recommend
relying on the log format to alert or monitor your application. Azure client libraries
do not guarantee the stability of log messages or context keys. For such purposes,
we recommend using distributed tracing. The Application Insights Java agent
provides stability guarantees for request and dependency telemetry. For more
information, see Configure tracing in the Azure SDK for Java.

Next steps
Now that you know how logging works in the Azure SDK for Java, consider reviewing
the following articles. These articles provide guidance on how to configure some of the
more popular Java logging frameworks to work with SLF4J and the Java client libraries:

java.util.logging
Logback
Log4J
Tracing

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Log with the Azure SDK for Java and
java.util.logging
Article • 04/01/2025

This article provides an overview of how to add logging using java.util.logging to

applications that use the Azure SDK for Java. The java.util.logging framework is part
of the JDK. As mentioned in Configure logging in the Azure SDK for Java, all Azure client
libraries log through Simple Logging Facade for Java (SLF4J) , so you can use logging
frameworks such as java.util.logging .

To enable java.util.logging , you must do two things:

1. Include the SLF4J adapter for java.util.logging as a dependency,

2. Create a file called logging.properties under the /src/main/resources project
directory.

For more information related to configuring your logger, see Configuring Logging
Output in the Oracle documentation.

Add the Maven dependency

To add the Maven dependency, include the following XML in the project's pom.xml file.
Replace the 1.7.30 version number with the latest released version number shown on
the SLF4J JDK14 Binding page .

XML

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-jdk14</artifactId>
<version>1.7.30</version> <!-- replace this version with the latest
available version on Maven central -->
</dependency>

Add logging.properties to your project

To log using java.util.logging , create a file called logging.properties under the
./src/main/resources directory of your project or anywhere else. This file will contain the
logging configurations to customize your logging needs. Provide path to the file by
setting the java.util.logging.config.file system property. You must set this property
before you create the logger instance. For more information, see Java Logging:
Configuration .

Console logging
You can create a configuration to log to the console as shown in the following example.
This example is configured to log all logging events that are INFO level or higher,
wherever they come from.

properties

handlers = java.util.logging.ConsoleHandler
.level = INFO

java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter =
java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=[%1$tF %1$tH:%1$tM:%1$tS.%1$tL]
[%4$s] %3$s %5$s %n

Log to a file
The previous example logs to the console, which isn't normally the preferred location for
logs. To configure logging to a file instead, use the following configuration:

properties

handlers = java.util.logging.FileHandler
.level = INFO

java.util.logging.FileHandler.pattern = %h/myapplication.log
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
java.util.logging.FileHandler.level = INFO

This code will create a file called myapplication.log in your home directory ( %h ). This
logger doesn't support automatic file rotation after a certain period. If you require this
functionality, you'll need to write a scheduler to manage log file rotation.

Next steps
This article covered the configuration of java.util.logging and how to make the Azure
SDK for Java use it for logging. Because the Azure SDK for Java works with all SLF4J
logging frameworks, consider reviewing the SLF4J user manual for further details.
After you've mastered logging, consider looking into the integrations that Azure offers
into frameworks such as Spring and MicroProfile.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Log with the Azure SDK for Java and
Logback
Article • 04/02/2025

This article provides an overview of how to add logging using Logback to applications
that use the Azure SDK for Java. As mentioned in Configure logging in the Azure SDK for
Java, all Azure client libraries log through SLF4J , so you can use logging frameworks
such as Logback .

To enable Logback logging, you must do two things:

1. Include the Logback library as a dependency,

2. Create a file called logback.xml in the /src/main/resources project directory.

For more information related to configuring Logback, see Logback configuration in

the Logback documentation.

Add the Maven dependency

To add the Maven dependency, include the following XML in the project's pom.xml file.
Replace the 1.2.3 version number with the latest released version number shown on
the Logback Classic Module page .

XML

<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>

Add logback.xml to your project

Logback is one of the popular logging frameworks. To enable Logback logging, create
a file called logback.xml in the ./src/main/resources directory of your project. This file
contains the logging configurations to customize your logging needs. For more
information on configuring logback.xml, see Logback configuration in the Logback
documentation.

Console logging
You can create a Logback configuration to log to the console as shown in the following
example. This example is configured to log all logging events that are INFO level or
higher, wherever they come from.

XML

<?xml version="1.0" encoding="UTF-8"?>

<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<Pattern>
%black(%d{ISO8601}) %highlight(%-5level) [%blue(%t)]
%blue(%logger{100}): %msg%n%throwable
</Pattern>
</layout>
</appender>

<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>

Log Azure core errors

The following example configuration is similar to the previous configuration, but it
lowers the level at which logging comes from all com.azure.core packaged classes
(including subpackages). This way, everything INFO-level and higher is logged, except
for com.azure.core , where only ERROR-level and higher is logged. For example, you can
use this approach if you find the code in com.azure.core too noisy. This kind of
configuration can also go both ways. For example, if you want to get more debug
information from classes in com.azure.core , you could change this setting to DEBUG.

It's possible to have fine-grained control over the logging of specific classes, or specific
packages. As shown here, com.azure.core controls the output of all core classes, but you
could equally use com.azure.security.keyvault or equivalent to control the output as
appropriate for the circumstances that are most informative in the context of the
running application.

XML

<?xml version="1.0" encoding="UTF-8"?>

<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%message%n</pattern>
</encoder>
 </appender>

<logger name="com.azure.core" level="ERROR" />

<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>

Log to a file with log rotation enabled

The previous examples log to the console, which isn't normally the preferred location for
logs. Use the following configuration to log to a file instead, with hourly roll-over, and
archiving in gzip format:

XML

<?xml version="1.0" encoding="UTF-8"?>

<configuration>
<property name="LOGS" value="./logs" />
<appender name="RollingFile"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${LOGS}/spring-boot-logger.log</file>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<Pattern>%d %p %C{1.} [%t] %m%n</Pattern>
</encoder>

<rollingPolicy
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- rollover hourly and gzip logs -->
<fileNamePattern>${LOGS}/archived/spring-boot-logger-%d{yyyy-MM-dd-
HH}.log.gz</fileNamePattern>
</rollingPolicy>
</appender>

<!-- LOG everything at INFO level -->

<root level="INFO">
<appender-ref ref="RollingFile" />
</root>
</configuration>

Spring applications
The Spring framework works by reading the Spring application.properties file for
various configurations, including the logging configuration. It's possible to configure the
Spring application to read Logback configurations from any file, however. To do so,
configure the logging.config property to point to the logback.xml configuration file by
adding the following line into your Spring /src/main/resources/application.properties
file:

properties

logging.config=classpath:logback.xml

Next steps
This article covered the configuration of Logback and how to make the Azure SDK for
Java use it for logging. Because the Azure SDK for Java works with all SLF4J logging
frameworks, consider reviewing the SLF4J user manual for further details. If you use
Logback, there's also a vast amount of configuration guidance on its website. For more
information, see Logback configuration in the Logback documentation.

After you've mastered logging, consider looking into the integrations that Azure offers
into frameworks such as Spring and MicroProfile.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Log with the Azure SDK for Java and Log4j
Article • 05/09/2025

This article provides an overview of how to add logging using Log4j to applications that use
the Azure SDK for Java. As mentioned in Configure logging in the Azure SDK for Java, all Azure
client libraries log through SLF4J , so you can use logging frameworks such as log4j .

This article provides guidance to use the Log4J 2.x releases, but Log4J 1.x is equally supported
by the Azure SDK for Java. To enable log4j logging, you must do two things:

1. Include the log4j library as a dependency,

2. Create a configuration file (either log4j2.properties or log4j2.xml) under the
/src/main/resources project directory.

For more information related to configuring log4j, see Welcome to Log4j 2 .

Add the Maven dependency

To add the Maven dependency, include the following XML in the project's pom.xml file.
Replace the 2.16.0 version number with the latest released version number shown on the
Apache Log4j SLF4J Binding page .

XML

<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.16.0</version>
</dependency>

７ Note

Due to known vulnerability CVE-2021-44228 , be sure to use Log4j version 2.16 or later

Configuring Log4j
There are two common ways to configure Log4j: through an external properties file, or through
an external XML file. These approaches are outlined below.

Using a property file

You can place a flat properties file named log4j2.properties in the /src/main/resources
directory of the project. This file should take the following form:

properties

appender.console.type = Console
appender.console.name = STDOUT
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %d %5p [%t] %c{3} - %m%n

logger.app.name = com.azure.core
logger.app.level = ERROR

rootLogger.level = info
rootLogger.appenderRefs = stdout
rootLogger.appenderRef.stdout.ref = STDOUT

Using an XML file

You can place an XML file named log4j2.xml in the /src/main/resources directory of the
project. This file should take the following form:

XML

<?xml version="1.0" encoding="UTF-8"?>

<Configuration status="INFO">
<Appenders>
<Console name="console" target="SYSTEM_OUT">
<PatternLayout pattern="%d %5p [%t] %c{3} - %m%n" />
</Console>
</Appenders>
<Loggers>
<Logger name="com.azure.core" level="error" additivity="true">
<appender-ref ref="console" />
</Logger>
<Root level="info" additivity="false">
<appender-ref ref="console" />
</Root>
</Loggers>
</Configuration>

Next steps
This article covered the configuration of Log4j and how to make the Azure SDK for Java use it
for logging. Because the Azure SDK for Java works with all SLF4J logging frameworks, consider
reviewing the SLF4J user manual for further details. If you use Log4j, there's also vast amount
of configuration guidance on its website. For more information, see Welcome to Log4j 2!
After you've mastered logging, consider looking into the integrations that Azure offers into
frameworks such as Spring.
HTTP clients and pipelines in the Azure
SDK for Java
Article • 04/01/2025

This article provides an overview of using the HTTP client and pipeline functionality
within the Azure SDK for Java. This functionality provides a consistent, powerful, and
flexible experience for developers using all Azure SDK for Java libraries.

HTTP clients
The Azure SDK for Java is implemented using an HttpClient abstraction. This
abstraction enables a pluggable architecture that accepts multiple HTTP client libraries
or custom implementations. However, to simplify dependency management for most
users, all Azure client libraries depend on azure-core-http-netty . As such, the Netty
HTTP client is the default client used in all Azure SDK for Java libraries.

Although Netty is the default HTTP client, the SDK provides three client
implementations, depending on which dependencies you already have in your project.
These implementations are for:

Netty
OkHttp
HttpClient introduced in JDK 11

７ Note

The JDK HttpClient in combination with the Azure SDK for Java is only supported
with JDK 12 and higher.

Replace the default HTTP client

If you prefer another implementation, you can remove the dependency on Netty by
excluding it in the build configuration files. In a Maven pom.xml file, you exclude the
Netty dependency and include another dependency.

The following example shows you how to exclude the Netty dependency from a real
dependency on the azure-security-keyvault-secrets library. Be sure to exclude Netty
from all appropriate com.azure libraries, as shown here:
 XML

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-security-keyvault-secrets</artifactId>
<version>4.2.2.</version>
<exclusions>
<exclusion>
<groupId>com.azure</groupId>
<artifactId>azure-core-http-netty</artifactId>
</exclusion>
</exclusions>
</dependency>

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-core-http-okhttp</artifactId>
<version>1.3.3</version>
</dependency>

７ Note

If you remove the Netty dependency but provide no implementation in its place,
the application fails to start. An HttpClient implementation must exist on the
classpath.

Configure HTTP clients

When you build a service client, it defaults to using HttpClient.createDefault() . This
method returns a basic HttpClient instance based on the provided HTTP client
implementation. In case you require a more complex HTTP client, such as a proxy, each
implementation offers a builder that allows you to construct a configured HttpClient
instance. The builders are NettyAsyncHttpClientBuilder , OkHttpAsyncHttpClientBuilder ,
and JdkAsyncHttpClientBuilder .

The following examples show how to build HttpClient instances using Netty, OkHttp,
and the JDK 11 HTTP client. These instances proxy through http://localhost:3128 and
authenticate with user example with password weakPassword .

Java

// Netty
HttpClient httpClient = new NettyAsyncHttpClientBuilder()
.proxy(new ProxyOptions(ProxyOptions.Type.HTTP, new
InetSocketAddress("localhost", 3128))
 .setCredentials("example", "weakPassword"))
.build();

// OkHttp
HttpClient httpClient = new OkHttpAsyncHttpClientBuilder()
.proxy(new ProxyOptions(ProxyOptions.Type.HTTP, new
InetSocketAddress("localhost", 3128))
.setCredentials("example", "weakPassword"))
.build();

// JDK 11 HttpClient
HttpClient client = new JdkAsyncHttpClientBuilder()
.proxy(new ProxyOptions(ProxyOptions.Type.HTTP, new
InetSocketAddress("localhost", 3128))
.setCredentials("example", "weakPassword"))
.build();

You can now pass the constructed HttpClient instance into a service client builder for
use as the client for communicating with the service. The following example uses the
new HttpClient instance to build an Azure Storage Blob client.

Java

BlobClient blobClient = new BlobClientBuilder()

.connectionString(<connection string>)
.containerName("container")
.blobName("blob")
.httpClient(httpClient)
.build();

For management libraries, you can set the HttpClient during Manager configuration.

Java

AzureResourceManager azureResourceManager = AzureResourceManager.configure()

.withHttpClient(httpClient)
.authenticate(credential, profile)
.withDefaultSubscription();

HTTP pipeline
The HTTP pipeline is one of the key components in achieving consistency and
diagnosability in the Java client libraries for Azure. An HTTP pipeline is composed of:

An HTTP transport
HTTP pipeline policies
You can provide your own custom HTTP pipeline when creating a client. If you don't
provide a pipeline, the client library creates one configured to work with that specific
client library.

HTTP transport
The HTTP transport is responsible for establishing the connection to the server, and
sending and receiving HTTP messages. The HTTP transport forms the gateway for the
Azure SDK client libraries to interact with Azure services. As noted earlier in this article,
the Azure SDK for Java uses Netty by default for its HTTP transport. However, the SDK
also provides a pluggable HTTP transport so you can use other implementations where
appropriate. The SDK also provides two more HTTP transport implementations for
OkHttp and the HTTP client that ships with JDK 11 and later.

HTTP pipeline policies

A pipeline consists of a sequence of steps executed for each HTTP request-response
roundtrip. Each policy has a dedicated purpose and acts on a request or a response or
sometimes both. Because all client libraries have a standard 'Azure Core' layer, this layer
ensures that each policy executes in order in the pipeline. When you send a request, the
policies execute in the order that they're added to the pipeline. When you receive a
response from the service, the policies execute in the reverse order. All policies added to
the pipeline execute before you send the request and after you receive a response. The
policy has to decide whether to act on the request, the response, or both. For example, a
logging policy logs the request and response but the authentication policy is only
interested in modifying the request.

The Azure Core framework provides the policy with the necessary request and response
data along with any necessary context to execute the policy. The policy can then
perform its operation with the given data and pass the control along to the next policy
in the pipeline.
HTTP pipeline policy position
When you make HTTP requests to cloud services, it's important to handle transient
failures and to retry failed attempts. Because this functionality is a common requirement,
Azure Core provides a retry policy that can watch for transient failures and automatically
retry the request.

This retry policy, therefore, splits the whole pipeline into two parts: policies that execute
before the retry policy and policies that execute after the retry policy. Policies added
before the retry policy execute only once per API operation, and policies added after the
retry policy execute as many times as the retries.

So, when building the HTTP pipeline, you should understand whether to execute a
policy for each request retry or once per API operation.

Common HTTP pipeline policies

HTTP pipelines for REST-based services have configurations with policies for
authentication, retries, logging, telemetry, and specifying the request ID in the header.
Azure Core is preloaded with these commonly required HTTP policies that you can add
to the pipeline.

ﾉ Expand table

Policy GitHub link

retry policy RetryPolicy.java

authentication policy BearerTokenAuthenticationPolicy.java

logging policy HttpLoggingPolicy.java

 Policy GitHub link

request ID policy RequestIdPolicy.java

telemetry policy UserAgentPolicy.java

Custom HTTP pipeline policy

The HTTP pipeline policy provides a convenient mechanism to modify or decorate the
request and response. You can add custom policies to the pipeline that the user or the
client library developer created. When adding the policy to the pipeline, you can specify
whether this policy should be executed per-call or per-retry.

To create a custom HTTP pipeline policy, you just extend a base policy type and
implement some abstract method. You can then plug the policy into the pipeline.

Custom headers in HTTP requests

The Azure SDK for Java client libraries provide a consistent way to define customized
headers through Context objects in the public API, as shown in the following example:

Java

// Add your headers

HttpHeaders headers = new HttpHeaders();
headers.set("my-header1", "my-header1-value");
headers.set("my-header2", "my-header2-value");
headers.set("my-header3", "my-header3-value");

// Call API by passing headers in Context.

configurationClient.addConfigurationSettingWithResponse(
new ConfigurationSetting().setKey("key").setValue("value"),
new Context(AddHeadersFromContextPolicy.AZURE_REQUEST_HTTP_HEADERS_KEY,
headers));

// The three headers are now be added to the outgoing HTTP request.

For more information, see the AddHeadersFromContextPolicy Class.

Default TLS/SSL library

All client libraries, by default, use the Tomcat-native Boring SSL library to enable native-
level performance for TLS/SSL operations. The Boring SSL library is an uber JAR
containing native libraries for Linux, macOS, and Windows, and provides better
performance compared to the default TLS/SSL implementation within the JDK.
Reduce Tomcat-Native TLS/SSL dependency size
By default, the uber JAR of the Tomcat-Native Boring SSL library is used in Azure SDKs
for Java. To reduce the size of this dependency, you need to include the dependency
with an os classifier as per netty-tcnative , as shown in the following example:

XML

<project>
...
<dependencies>
...
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-tcnative-boringssl-static</artifactId>
<version>2.0.25.Final</version>
<classifier>${os.detected.classifier}</classifier>
</dependency>
...
</dependencies>
...
<build>
...
<extensions>
<extension>
<groupId>kr.motd.maven</groupId>
<artifactId>os-maven-plugin</artifactId>
<version>1.4.0.Final</version>
</extension>
</extensions>
...
</build>
...
</project>

Use JDK TLS/SSL

If you'd rather use the default JDK TLS/SSL instead of Tomcat-Native Boring SSL, then
you need to exclude the Tomcat-native Boring SSL library. Be aware that, based on our
tests, the performance of JDK TLS/SSL is 30% slower compared to Tomcat-Native Boring
SSL. When you use com.azure:azure-core:1.28.0 or later, the HttpClient -implementing
library (such as com.azure:azure-core-http-netty ) manages the dependency on Tomcat-
Native Boring SSL. To exclude the dependency, add the following configuration to your
POM file:

XML
 <project>
...
<dependencies>
...
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-core-http-netty</artifactId>
<version>1.13.6</version>
<exclusions>
<exclusion>
<groupId>io.netty</groupId>
<artifactId>netty-tcnative-boringssl-static</artifactId>
</exclusion>
</exclusions>
</dependency>
...
</dependencies>
...
</project>

Next steps
Now that you're familiar with HTTP client functionality in the Azure SDK for Java, learn
how to further customize the HTTP client you're using. For more information, see
Configure proxies in the Azure SDK for Java.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Asynchronous programming in the
Azure SDK for Java
Article • 02/14/2025

This article describes the asynchronous programming model in the Azure SDK for Java.

The Azure SDK initially contained only non-blocking, asynchronous APIs for interacting
with Azure services. These APIs let you use the Azure SDK to build scalable applications
that use system resources efficiently. However, the Azure SDK for Java also contains
synchronous clients to cater to a wider audience, and also make our client libraries
approachable for users not familiar with asynchronous programming. (See
Approachable in the Azure SDK design guidelines.) As such, all Java client libraries in
the Azure SDK for Java offer both asynchronous and synchronous clients. However, we
recommend using the asynchronous clients for production systems to maximize the use
of system resources.

Reactive streams
If you look at the Async Service Clients section in the Java Azure SDK Design
Guidelines , you'll notice that, instead of using CompletableFuture provided by Java 8,
our async APIs use reactive types. Why did we choose reactive types over types that are
natively available in JDK?

Java 8 introduced features like Streams , Lambdas , and CompletableFuture . These

features provide many capabilities, but have some limitations.

CompletableFuture provides callback-based, non-blocking capabilities, and the

CompletionStage interface allowed for easy composition of a series of asynchronous

operations. Lambdas make these push-based APIs more readable. Streams provide
functional-style operations to handle a collection of data elements. However, streams
are synchronous and can't be reused. CompletableFuture allows you to make a single
request, provides support for a callback, and expects a single response. However, many
cloud services require the ability to stream data - Event Hubs for instance.

Reactive streams can help to overcome these limitations by streaming elements from a
source to a subscriber. When a subscriber requests data from a source, the source sends
any number of results back. It doesn't need to send them all at once. The transfer
happens over a period of time, whenever the source has data to send.
In this model, the subscriber registers event handlers to process data when it arrives.
These push-based interactions notify the subscriber through distinct signals:

An onSubscribe() call indicates that the data transfer is about to begin.

An onError() call indicates there was an error, which also marks the end of data
transfer.
An onComplete() call indicates successful completion of data transfer.

Unlike Java Streams, reactive streams treat errors as first-class events. Reactive streams
have a dedicated channel for the source to communicate any errors to the subscriber.
Also, reactive streams allow the subscriber to negotiate the data transfer rate to
transform these streams into a push-pull model.

The Reactive Streams specification provides a standard for how the transfer of data
should occur. At a high level, the specification defines the following four interfaces and
specifies rules on how these interfaces should be implemented.

Publisher is the source of a data stream.

Subscriber is the consumer of a data stream.
Subscription manages the state of data transfer between a publisher and a
subscriber.
Processor is both a publisher and a subscriber.

There are some well-known Java libraries that provide implementations of this
specification, such as RxJava , Akka Streams , Vert.x , and Project Reactor .

The Azure SDK for Java adopted Project Reactor to offer its async APIs. The main factor
driving this decision was to provide smooth integration with Spring Webflux , which
also uses Project Reactor. Another contributing factor to choose Project Reactor over
RxJava was that Project Reactor uses Java 8 but RxJava, at the time, was still at Java 7.
Project Reactor also offers a rich set of operators that are composable and allow you to
write declarative code for building data processing pipelines. Another nice thing about
Project Reactor is that it has adapters for converting Project Reactor types to other
popular implementation types.

Comparing APIs of synchronous and

asynchronous operations
We discussed the synchronous clients and options for asynchronous clients. The table
below summarizes what APIs look like that are designed using these options:
 ﾉ Expand table

API Type No value Single value Multiple values

Standard Java - void T Iterable<T>

Synchronous
APIs

Standard Java - CompletableFuture<Void> CompletableFuture<T> CompletableFuture<List<T>>

Asynchronous
APIs

Reactive Publisher<Void> Publisher<T> Publisher<T>

Streams
Interfaces

Project Reactor Mono<Void> Mono<T> Flux<T>

implementation
of Reactive
Streams

For the sake of completeness, it's worth mentioning that Java 9 introduced the Flow
class that includes the four reactive streams interfaces. However, this class doesn't
include any implementation.

Use async APIs in the Azure SDK for Java

The reactive streams specification doesn't differentiate between types of publishers. In
the reactive streams specification, publishers simply produce zero or more data
elements. In many cases, there's a useful distinction between a publisher producing at
most one data element versus one that produces zero or more. In cloud-based APIs, this
distinction indicates whether a request returns a single-valued response or a collection.
Project Reactor provides two types to make this distinction - Mono and Flux . An API
that returns a Mono will contain a response that has at most one value, and an API that
returns a Flux will contain a response that has zero or more values.

For example, suppose you use a ConfigurationAsyncClient to retrieve a configuration

stored using the Azure App Configuration service. (For more information, see What is
Azure App Configuration?.)

If you create a ConfigurationAsyncClient and call getConfigurationSetting() on the

client, it returns a Mono , which indicates that the response contains a single value.
However, calling this method alone doesn't do anything. The client has not yet made a
request to the Azure App Configuration service. At this stage, the
Mono<ConfigurationSetting> returned by this API is just an "assembly" of data
processing pipeline. What this means is that the required setup for consuming the data
is complete. To actually trigger the data transfer (that is, to make the request to the
service and get the response), you must subscribe to the returned Mono . So, when
dealing with these reactive streams, you must remember to call subscribe() because
nothing happens until you do so.

The following example shows how to subscribe to the Mono and print the configuration
value to the console.

Java

ConfigurationAsyncClient asyncClient = new ConfigurationClientBuilder()

.connectionString("<your connection string>")
.buildAsyncClient();

asyncClient.getConfigurationSetting("<your config key>", "<your config

value>").subscribe(
config -> System.out.println("Config value: " + config.getValue()),
ex -> System.out.println("Error getting configuration: " +
ex.getMessage()),
() -> System.out.println("Successfully retrieved configuration
setting"));

System.out.println("Done");

Notice that after calling getConfigurationSetting() on the client, the example code
subscribes to the result and provides three separate lambdas. The first lambda
consumes data received from the service, which is triggered upon successful response.
The second lambda is triggered if there is an error while retrieving the configuration.
The third lambda is invoked when the data stream is complete, meaning no more data
elements are expected from this stream.

７ Note

As with all asynchronous programming, after the subscription is created, execution

proceeds as usual. If there's nothing to keep the program active and executing, it
may terminate before the async operation completes. The main thread that called
subscribe() won't wait until you make the network call to Azure App Configuration
and receive a response. In production systems, you might continue to process
something else, but in this example you can add a small delay by calling
Thread.sleep() or use a CountDownLatch to give the async operation a chance to

complete.
As shown in the following example, APIs that return a Flux also follow a similar pattern.
The difference is that the first callback provided to the subscribe() method is called
multiple times for each data element in the response. The error or the completion
callbacks are called exactly once and are considered as terminal signals. No other
callbacks are invoked if either of these signals are received from the publisher.

Java

EventHubConsumerAsyncClient asyncClient = new EventHubClientBuilder()

.connectionString("<your connection string>")
.consumerGroup("<your consumer group>")
.buildAsyncConsumerClient();

asyncClient.receive().subscribe(
event -> System.out.println("Sequence number of received event: " +
event.getData().getSequenceNumber()),
ex -> System.out.println("Error receiving events: " + ex.getMessage()),
() -> System.out.println("Successfully completed receiving all
events"));

Backpressure
What happens when the source is producing the data at a faster rate than the subscriber
can handle? The subscriber can get overwhelmed with data, which can lead to out-of-
memory errors. The subscriber needs a way to communicate back to the publisher to
slow down when it can't keep up. By default, when you call subscribe() on a Flux as
shown in the example above, the subscriber is requesting an unbounded stream of data,
indicating to the publisher to send the data as quickly as possible. This behavior isn't
always desirable, and the subscriber may have to control the rate of publishing through
"backpressure". Backpressure allows the subscriber to take control of the flow of data
elements. A subscriber will request a limited number of data elements that they can
handle. After the subscriber has completed processing these elements, the subscriber
can request more. By using backpressure, you can transform a push-model for data
transfer into a push-pull model.

The following example shows how you can control the rate at which events are received
by the Event Hubs consumer:

Java

EventHubConsumerAsyncClient asyncClient = new EventHubClientBuilder()

.connectionString("<your connection string>")
.consumerGroup("<your consumer group>")
.buildAsyncConsumerClient();
 asyncClient.receive().subscribe(new Subscriber<PartitionEvent>() {
private Subscription subscription;

@Override
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
this.subscription.request(1); // request 1 data element to begin
with
}

@Override
public void onNext(PartitionEvent partitionEvent) {
System.out.println("Sequence number of received event: " +
partitionEvent.getData().getSequenceNumber());
this.subscription.request(1); // request another event when the
subscriber is ready
}

@Override
public void onError(Throwable throwable) {
System.out.println("Error receiving events: " +
throwable.getMessage());
}

@Override
public void onComplete() {
System.out.println("Successfully completed receiving all events")
}
});

When the subscriber first "connects" to the publisher, the publisher hands the subscriber
a Subscription instance, which manages the state of the data transfer. This
Subscription is the medium through which the subscriber can apply backpressure by

calling request() to specify how many more data elements it can handle.

If the subscriber requests more than one data element each time it calls onNext() ,
request(10) for example, the publisher will send the next 10 elements immediately if

they're available or when they become available. These elements accumulate in a buffer
on the subscriber's end, and since each onNext() call will request 10 more, the backlog
keeps growing until either the publisher has no more data elements to send, or the
subscriber's buffer overflows, resulting in out-of-memory errors.

Cancel a subscription
A subscription manages the state of data transfer between a publisher and a subscriber.
The subscription is active until the publisher has completed transferring all the data to
the subscriber or the subscriber is no longer interested in receiving data. There are a
couple of ways you can cancel a subscription as shown below.
The following example cancels the subscription by disposing the subscriber:

Java

EventHubConsumerAsyncClient asyncClient = new EventHubClientBuilder()

.connectionString("<your connection string>")
.consumerGroup("<your consumer group>")
.buildAsyncConsumerClient();

Disposable disposable = asyncClient.receive().subscribe(

partitionEvent -> {
Long num = partitionEvent.getData().getSequenceNumber()
System.out.println("Sequence number of received event: " + num);
},
ex -> System.out.println("Error receiving events: " + ex.getMessage()),
() -> System.out.println("Successfully completed receiving all
events"));

// much later on in your code, when you are ready to cancel the
subscription,
// you can call the dispose method, as such:
disposable.dispose();

The follow example cancels the subscription by calling the cancel() method on
Subscription :

Java

EventHubConsumerAsyncClient asyncClient = new EventHubClientBuilder()

.connectionString("<your connection string>")
.consumerGroup("<your consumer group>")
.buildAsyncConsumerClient();

asyncClient.receive().subscribe(new Subscriber<PartitionEvent>() {
private Subscription subscription;

@Override
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
this.subscription.request(1); // request 1 data element to begin
with
}

@Override
public void onNext(PartitionEvent partitionEvent) {
System.out.println("Sequence number of received event: " +
partitionEvent.getData().getSequenceNumber());
this.subscription.cancel(); // Cancels the subscription. No further
event is received.
}

@Override
 public void onError(Throwable throwable) {
System.out.println("Error receiving events: " +
throwable.getMessage());
}

@Override
public void onComplete() {
System.out.println("Successfully completed receiving all events")
}
});

Conclusion
Threads are expensive resources that you shouldn't waste on waiting for responses from
remote service calls. As the adoption of microservices architectures increase, the need to
scale and use resources efficiently becomes vital. Asynchronous APIs are favorable when
there are network-bound operations. The Azure SDK for Java offers a rich set of APIs for
async operations to help maximize your system resources. We highly encourage you to
try out our async clients.

For more information on the operators that best suit your particular tasks, see Which
operator do I need? in the Reactor 3 Reference Guide .

Next steps
Now that you better understand the various asynchronous programming concepts, it's
important to learn how to iterate over the results. For more information on the best
iteration strategies, and details of how pagination works, see Pagination and iteration in
the Azure SDK for Java.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Pagination and iteration in the Azure
SDK for Java
Article • 04/02/2025

This article provides an overview of how to use the Azure SDK for Java pagination and
iteration functionality to work efficiently and productively with large data sets.

Many operations provided by the client libraries within the Azure Java SDK return more
than one result. The Azure Java SDK defines a set of acceptable return types in these
cases to ensure that developer experience is maximized through consistency. The return
types used are PagedIterable for sync APIs and PagedFlux for async APIs. The APIs
differ slightly on account of their different use cases, but conceptually they have the
same requirements:

Make it possible to easily iterate over each element in the collection individually,
ignoring any need for manual pagination or tracking of continuation tokens. Both
PagedIterable and PagedFlux make this task easy by iterating over a paginated

response deserialized into a given type T . PagedIterable implements the Iterable

interface, and offers an API to receive a Stream , while PagedFlux provides a Flux .
In all cases, the act of pagination is transparent, and iteration continues while there
are still results iterate over.

Make it possible to iterate explicitly page-by-page. Doing so lets you understand

more clearly when requests are made, and lets you access per-page response
information. Both PagedIterable and PagedFlux have methods that will return
appropriate types to iterate by page, rather than by individual element.

This article is split between the Java Azure SDK synchronous and asynchronous APIs.
You'll see the synchronous iteration APIs when you work with synchronous clients, and
asynchronous iteration APIs when you work with asynchronous clients.

Synchronous pagination and iteration

This section covers the synchronous APIs.

Iterate over individual elements

As noted, the most common use case is to iterate over each element individually, rather
than per page. The following code examples show how the PagedIterable API lets you
use the iteration style you prefer to implement this functionality.

Use a for-each loop

Because PagedIterable implements Iterable , you can iterate through the elements as
shown in the following example:

Java

PagedIterable<Secret> secrets = client.listSecrets();

for (Secret secret : secrets) {
System.out.println("Secret is: " + secret);
}

Use Stream

Because PagedIterable has a stream() method defined on it, you can call it to use the
standard Java Stream APIs, as shown in the following example:

Java

client.listSecrets()
.stream()
.forEach(secret -> System.out.println("Secret is: " + secret));

Use Iterator
Because PagedIterable implements Iterable , it also has an iterator() method to
allow for the Java iterator programming style, as show in the following example:

Java

Iterator<Secret> secrets = client.listSecrets().iterator();

while (it.hasNext()) {
System.out.println("Secret is: " + it.next());
}

Iterate over pages

When you work with individual pages, you can iterate per page, for example when you
need HTTP response information, or when continuation tokens are important to retain
iteration history. Regardless of whether you iterate by page or by each item, there's no
difference in performance or the number of calls made to the service. The underlying
implementation loads the next page on demand, and if you unsubscribe from the
PagedFlux at any time, there are no further calls to the service.

Use a for-each loop

When you call listSecrets() , you get a PagedIterable , which has an iterableByPage()
API. This API produces an Iterable<PagedResponse<Secret>> instead of an
Iterable<Secret> . The PagedResponse provides the response metadata and access to the

continuation token, as shown in the following example:

Java

Iterable<PagedResponse<Secret>> secretPages =
client.listSecrets().iterableByPage();
for (PagedResponse<Secret> page : secretPages) {
System.out.println("Response code: " + page.getStatusCode());
System.out.println("Continuation Token: " + page.getContinuationToken());
page.getElements().forEach(secret -> System.out.println("Secret value: "
+ secret))
}

There's also an iterableByPage overload that accepts a continuation token. You can call
this overload when you want to return to the same point of iteration at a later time.

Use Stream
The following example shows how the streamByPage() method performs the same
operation as shown above. This API also has a continuation token overload for returning
to the same point of iteration at a later time.

Java

client.listSecrets()
.streamByPage()
.forEach(page -> {
System.out.println("Response code: " + page.getStatusCode());
System.out.println("Continuation Token: " +
page.getContinuationToken());
page.getElements().forEach(secret -> System.out.println("Secret
value: " + secret))
});
Asynchronously observe pages and individual
elements
This section covers the asynchronous APIs. In async APIs, the network calls happen in a
different thread than the main thread that calls subscribe() . What this means is that the
main thread may terminate before the result is available. It's up to you to ensure that
the application doesn't exit before the async operation has had time to complete.

Observe individual elements

The following example shows how the PagedFlux API lets you observe individual
elements asynchronously. There are various ways to subscribe to a Flux type. For more
information, see Simple Ways to Create a Flux or Mono and Subscribe to It in the
Reactor 3 Reference Guide . This example is one variety where there are three lambda
expressions, one each for the consumer, the error consumer, and the complete
consumer. Having all three is good practice, but in some cases it's only necessary to
have the consumer, and possibly the error consumer.

Java

asyncClient.listSecrets()
.subscribe(secret -> System.out.println("Secret value: " + secret),
ex -> System.out.println("Error listing secrets: " +
ex.getMessage()),
() -> System.out.println("Successfully listed all secrets"));

Observe pages
The following example shows how the PagedFlux API lets you observe each page
asynchronously, again by using a byPage() API and by providing a consumer, error
consumer, and a completion consumer.

Java

asyncClient.listSecrets().byPage()
.subscribe(page -> {
System.out.println("Response code: " + page.getStatusCode());
System.out.println("Continuation Token: " +
page.getContinuationToken());
page.getElements().forEach(secret -> System.out.println("Secret
value: " + secret))
},
ex -> System.out.println("Error listing pages with secret: " +
ex.getMessage()),
 () -> System.out.println("Successfully listed all pages with
secret"));

Next steps
Now that you're familiar with pagination and iteration in the Azure SDK for Java,
consider reviewing Long-running operations in the Azure SDK for Java. Long-running
operations are operations that run for a longer duration than most normal HTTP
requests, typically because they require some effort on the server side.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Long-running operations in the Azure
SDK for Java
Article • 04/02/2025

This article provides an overview of using long-running operations with the Azure SDK
for Java.

Certain operations on Azure may take extended amounts of time to complete. These
operations are outside the standard HTTP style of quick request / response flow. For
example, copying data from a source URL to a Storage blob, or training a model to
recognize forms, are operations that may take a few seconds to several minutes. Such
operations are referred to as Long-Running Operations, and are often abbreviated as
'LRO'. An LRO may take seconds, minutes, hours, days, or longer to complete,
depending on the operation requested and the process that must be performed on the
server side.

In the Java client libraries for Azure, a convention exists that all long-running operations
begin with the begin prefix. This prefix indicates that this operation is long-running, and
that the means of interaction with this operation is slightly different that the usual
request / response flow. Along with the begin prefix, the return type from the operation
is also different than usual, to enable the full range of long-running operation
functionality. As with most things in the Azure SDK for Java, there are both synchronous
and asynchronous APIs for long-running operations:

In synchronous clients, long-running operations will return a SyncPoller instance.

In asynchronous clients, long-running operations will return a PollerFlux instance.

Both SyncPoller and PollerFlux are the client-side abstractions intended to simplify
the interaction with long-running server-side operations. The rest of this article outlines
best practices when working with these types.

Synchronous long-running operations

Calling any API that returns a SyncPoller will immediately start the long-running
operation. The API will return the SyncPoller immediately, letting you monitor the
progress of the long-running operation and retrieve the final result. The following
example shows how to monitor the progress of a long-running operation using the
SyncPoller .

Java
 SyncPoller<UploadBlobProgress, UploadedBlobProperties> poller =
syncClient.beginUploadFromUri(<URI to upload from>)
PollResponse<UploadBlobProgress> response;

do {
response = poller.poll();
System.out.println("Status of long running upload operation: " +
response.getStatus());
Duration pollInterval = response.getRetryAfter();
TimeUnit.MILLISECONDS.sleep(pollInterval.toMillis());
} while (!response.getStatus().isComplete());

This example uses the poll() method on the SyncPoller to retrieve information on
progress of the long-running operation. This code prints the status to the console, but a
better implementation would make relevant decisions based on this status.

The getRetryAfter() method returns information about how long to wait before the
next poll. Most Azure long-running operations return the poll delay as part of their
HTTP response (that is, the commonly used retry-after header). If the response
doesn't contain the poll delay, then the getRetryAfter() method returns the duration
given at the time of invoking the long-running operation.

The example above uses a do..while loop to repeatedly poll until the long-running
operation is complete. If you aren't interested in these intermediate results, you can
instead call waitForCompletion() . This call will block the current thread until the long-
running operation completes and returns the last poll response:

Java

PollResponse<UploadBlobProgress> response = poller.waitForCompletion();

If the last poll response indicates that the long-running operation has completed
successfully, you can retrieve the final result using getFinalResult() :

Java

if (LongRunningOperationStatus.SUCCESSFULLY_COMPLETED ==
response.getStatus()) {
UploadedBlobProperties result = poller.getFinalResult();
}

Other useful APIs in SyncPoller include:

 1. waitForCompletion(Duration) : wait for the long-running operation to complete, for
the given timeout duration.
2. waitUntil(LongRunningOperationStatus) : wait until the given long-running
operation status is received.
3. waitUntil(LongRunningOperationStatus, Duration) : wait until the given long-
running operation status is received, or until the given timeout duration expires.

Asynchronous long-running operations

The example below shows how the PollerFlux lets you observe a long-running
operation. In async APIs, the network calls happen in a different thread than the main
thread that calls subscribe() . What this means is that the main thread may terminate
before the result is available. It's up to you to ensure that the application doesn't exit
before the async operation has had time to complete.

The async API returns a PollerFlux immediately, but the long-running operation itself
won't start until you subscribe to the PollerFlux . This process is how all Flux -based
APIs operate. The following example shows an async long-running operation:

Java

asyncClient.beginUploadFromUri(...)
.subscribe(response -> System.out.println("Status of long running upload
operation: " + response.getStatus()));

In the following example, you'll get intermittent status updates on the long-running
operation. You can use these updates to determine whether the long-running operation
is still operating in the expected fashion. This example prints the status to the console,
but a better implementation would make relevant error handling decisions based on this
status.

If you aren't interested in the intermediate status updates and just want to get notified
of the final result when it arrives, you can use code similar to the following example:

Java

asyncClient.beginUploadFromUri(...)
.last()
.flatMap(response -> {
if (LongRunningOperationStatus.SUCCESSFULLY_COMPLETED ==
response.getStatus()) {
return response.getFinalResult();
}
return Mono.error(new IllegalStateException("Polling completed
 unsuccessfully with status: "+ response.getStatus()));
})
.subscribe(
finalResult -> processFormPages(finalResult),
ex -> countDownLatch.countDown(),
() -> countDownLatch.countDown());

In this code, you retrieve the final result of the long-running operation by calling
last() . This call tells the PollerFlux that you want to wait for all the polling to

complete, at which point the long-running operation has reached a terminal state, and
you can inspect its status to determine the outcome. If the poller indicates that the
long-running operation has completed successfully, you can retrieve the final result and
pass it on to the consumer in the subscribe call.

Next steps
Now that you're familiar with the long-running APIs in the Azure SDK for Java, see
Configure proxies in the Azure SDK for Java to learn how to customize the HTTP client
further.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Configure proxies in the Azure SDK for
Java
Article • 04/01/2025

This article provides an overview of how to configure the Azure SDK for Java to make
proper use of proxies.

HTTP proxy configuration

The Azure client libraries for Java offer multiple ways to configure a proxy for an
HttpClient .

Each method of supplying a proxy has its own pros and cons and provides different
levels of encapsulation. When you've configured a proxy for an HttpClient , it will use
the proxy for the rest of its lifetime. Having the proxy tied to an individual HttpClient
allows an application to use multiple HttpClient instances where each can use a
different proxy to fulfill an application's proxying requirements.

The proxy configuration options are:

Use an environment proxy

Use a Configuration proxy
Use an explicit proxy

Use an environment proxy

By default, HTTP client builders will inspect the environment for proxy configurations.
This process makes use of the Azure SDK for Java Configuration APIs. When the builder
creates a client, it's configured with a copy of the 'global configuration' retrieved by
calling Configuration.getGlobalConfiguration() . This call will read in any HTTP proxy
configuration from the system environment.

When the builder inspects the environment, it will search for the following environment
configurations in the order specified:

1. HTTPS_PROXY
2. HTTP_PROXY
3. https.proxy*
4. http.proxy*
The * represents the well-known Java proxy properties. For more information, see Java
Networking and Proxies in the Oracle documentation.

If the builder finds any of the environment configurations, it creates a ProxyOptions

instance by calling
ProxyOptions.fromConfiguration(Configuration.getGlobalConfiguration()) . This article

provides more details below about the ProxyOptions type.

） Important

To use any proxy configuration, Java requires you to set the system environment
property java.net.useSystemProxies to true .

You can also create an HTTP client instance that doesn't use any proxy configuration
present in the system environment variables. To override the default behavior, you
explicitly set a differently-configured Configuration in the HTTP client builder. When
you set a Configuration in the builder, it will no longer call
Configuration.getGlobalConfiguration() . For example, if you call

configuration(Configuration) using Configuration.NONE , you can explicitly prevent the

builder from inspecting the environment for configuration.

The following example uses the HTTP_PROXY environment variable with value
localhost:8888 to use Fiddler as the proxy. This code demonstrates creating a Netty

and an OkHttp HTTP client. (For more information on HTTP client configuration, see
HTTP clients and pipelines.)

Bash

export HTTP_PROXY=localhost:8888

Java

HttpClient nettyHttpClient = new NettyAsyncHttpClientBuilder().build();

HttpClient okhttpHttpClient = new OkHttpAsyncHttpClientBuilder().build();

To prevent the environment proxy from being used, configure the HTTP client builder
with Configuration.NONE , as shown in the following example:

Java

HttpClient nettyHttpClient = new NettyAsyncHttpClientBuilder()

.configuration(Configuration.NONE)
 .build();

HttpClient okhttpHttpClient = new OkHttpAsyncHttpClientBuilder()

.configuration(Configuration.NONE)
.build();

Use a Configuration proxy

Rather than read from the environment, you can configure HTTP client builders to use a
custom Configuration with the same proxy settings that are already accepted from the
environment. This configuration offers the ability to have reusable configurations that
are scoped to a limited use case. When the HTTP client builder is building the
HttpClient , it will use the ProxyOptions returned from
ProxyOptions.fromConfiguration(<Configuration passed into the builder>) .

The following example uses the http.proxy* configurations set in a Configuration

object to use a proxy that authenticates Fiddler as the proxy.

Java

Configuration configuration = new Configuration()

.put("java.net.useSystemProxies", "true")
.put("http.proxyHost", "localhost")
.put("http.proxyPort", "8888")
.put("http.proxyUser", "1")
.put("http.proxyPassword", "1");

HttpClient nettyHttpClient = new NettyAsyncHttpClientBuilder()

.configuration(configuration)
.build();

HttpClient okhttpHttpClient = new OkHttpAsyncHttpClientBuilder()

.configuration(configuration)
.build();

Use an explicit proxy

The Java client libraries ship with a ProxyOptions class that acts as the Azure client
libraries type for configuring a proxy. You can configure ProxyOptions with the network
protocol used to send proxy requests, the proxy address, proxy authentication
credentials, and non-proxying hosts. Only the proxy network protocol and proxy address
are required. When using authentication credentials, you must set both the username
and password.
The following example creates a simple ProxyOptions instance that proxies requests to
the default Fiddler address ( localhost:8888 ):

Java

ProxyOptions proxyOptions = new ProxyOptions(ProxyOptions.Type.HTTP, new

InetSocketAddress("localhost", 8888));

The following example creates an authenticated ProxyOptions that proxies requests to a

Fiddler instance requiring proxy authentication:

Java

// Fiddler uses username "1" and password "1" with basic authentication as
its proxy authentication requirement.
ProxyOptions proxyOptions = new ProxyOptions(ProxyOptions.Type.HTTP, new
InetSocketAddress("localhost", 8888))
.setCredentials("1", "1");

You can configure HTTP client builders with ProxyOptions directly to indicate an explicit
proxy to use. This configuration is the most granular way to provide a proxy, and
generally isn't as flexible as passing a Configuration that you can mutate to update
proxying requirements.

The following example uses ProxyOptions to use Fiddler as the proxy:

Java

ProxyOptions proxyOptions = new ProxyOptions(ProxyOptions.Type.HTTP, new

InetSocketAddress("localhost", 8888));

HttpClient nettyHttpClient = new NettyAsyncHttpClientBuilder()

.proxy(proxyOptions)
.build();

HttpClient okhttpHttpClient = new OkHttpAsyncHttpClientBuilder()

.proxy(proxyOptions)
.build();

Next steps
Now that you're familiar with proxy configuration in the Azure SDK for Java, see
Configure tracing in the Azure SDK for Java to better understand flows within your
application, and to help diagnose issues.
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Configure tracing in the Azure SDK for
Java
Article • 04/01/2025

This article provides an overview of how to configure the Azure SDK for Java to integrate
tracing functionality.

You can enable tracing in Azure client libraries by using and configuring the
OpenTelemetry SDK or using an OpenTelemetry-compatible agent. OpenTelemetry is a
popular open-source observability framework for generating, capturing, and collecting
telemetry data for cloud-native software.

There are two key concepts related to tracing: span and trace. A span represents a
single operation in a trace. A span can represent an HTTP request, a remote procedure
call (RPC), a database query, or even the path that your code takes. A trace is a tree of
spans showing the path of work through a system. You can distinguish a trace on its
own by a unique 16-byte sequence called a TraceID. For more information on these
concepts and how they relate to OpenTelemetry, see the OpenTelemetry
documentation .

Azure SDK tracing with Azure Monitor Java

agent
By using an Azure Monitor Java in-process agent, you can enable monitoring of your
applications without any code changes. For more information, see Azure Monitor
OpenTelemetry-based auto-instrumentation for Java applications. Azure SDK support is
enabled by default starting with agent version 3.2.

Tracing Azure SDK calls with OpenTelemetry

agent
If you use OpenTelemetry Java agent , Azure SDK instrumentation is enabled out-of-
the-box starting from version 1.12.0.

For more details on how to configure exporters, add manual instrumentation, or enrich
telemetry, see OpenTelemetry Instrumentation for Java .

７ Note
 OpenTelemetry agent artifact is stable, but does not provide over-the-wire
telemetry stability guarantees, which may cause span names and attribute names
produced by Azure SDK that might change over time if you update the agent. For
more information, see Compatibility requirements .

Manually instrument the application with OpenTelemetry

SDK (preview)
If you use OpenTelemetry SDK directly, make sure to configure SDK and exporter for the
backend of your choice. For more information, see OpenTelemetry documentation .

To enable Azure SDK tracing, add the latest com.azure:azure-core-tracing-

opentelemetry packages to your application. For example, in Maven, add the following

entry to your pom.xml file:

XML

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-core-tracing-opentelemetry</artifactId>
</dependency>

If you run the application now, you should get Azure SDK spans on your backend.
However with asynchronous calls, the correlation between Azure SDK and application
spans may be broken.

By default, Azure SDK uses io.opentelemetry.context.Context.current() , implicitly

propagated by OpenTelemetry, as a parent to new spans. In asynchronous calls, implicit
context propagation breaks. OpenTelemetry agents solve this problem by helping
context propagate, but the OpenTelemetry SDK doesn't have such capabilities.

Pass trace context explicitly

Azure SDK allows passing trace context explicitly through com.azure.core.util.Context
under the trace-context key. When you provide explicit trace context, Azure SDK uses it
instead of the implicit one, which enables correlation between application and Azure
SDK spans.

In the following example, when an incoming web request is traced manually, the
Application Configuration Client Library is called asynchronously in the scope of this
request.
 Java

Span span = TRACER.spanBuilder("incoming request").startSpan();

io.opentelemetry.context.Context traceContext =
io.opentelemetry.context.Context.root().with(span);

// Put the incoming-request span (wrapped into the OpenTelemetry Context)

into the Azure SDK Context
// and pass it over to the Application Configuration call.
appConfigClient.setConfigurationSettingWithResponse(settings, true, new
com.azure.core.util.Context("trace-context", traceContext));

// You could also pass the context using the reactor `contextWrite` method
under the same `trace-context` key.
appConfigAsyncClient.setConfigurationSettingWithResponse(settings)
.contextWrite(reactor.util.context.Context.of("trace-context",
traceContext))

//...

Azure SDK tracing conventions

To find out which spans and attributes the SDK emits, see the Azure SDK semantic
conventions specification . Azure SDK (and OpenTelemetry) semantic conventions are
not stable and may change in the future.

Next steps
Now that you're familiar with the core cross-cutting functionality in the Azure SDK for
Java, see Azure authentication with Java and Azure Identity to learn how you can create
secure applications.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure Toolkit for IntelliJ documentation
The Azure Toolkit for IntelliJ provides templates and functionality that you can use to
easily create, develop, test, and deploy Azure applications by using the IntelliJ integrated
development environment (IDE).

Get started guides

ｆ QUICKSTART

Create a Hello World web app for Azure App Service

Create an HTTP trigger Function for Azure Functions

Step-by-step tutorials

ｇ TUTORIAL

Run a Hello World web app in a Linux container

Create Spark applications for an HDInsight Spark Linux cluster

Manage Azure resources

ｃ HOW-TO GUIDE

Redis caches

Storage accounts

Virtual machines

Supported JDKs

ａ DOWNLOAD

Java for Azure and Azure Stack

Source code

ｉ REFERENCE

Azure Toolkits for Java

Azure Toolkit for Eclipse documentation
The Azure Toolkit for Eclipse provides templates and functionality that you can use to
easily create, develop, test, and deploy cloud applications to Azure from inside the
Eclipse IDE.

Get started guides

ｆ QUICKSTART

Create a Hello World web app for Azure App Service

Step-by-step tutorials

ｇ TUTORIAL

Create Spark applications for an HDInsight Spark Linux cluster

Manage Azure resources

ｃ HOW-TO GUIDE

Redis caches

Storage accounts

Virtual machines

Supported JDKs

ａ DOWNLOAD

Java for Azure and Azure Stack

Source code
ｉ REFERENCE

Azure Toolkits for Java

What is Spring Cloud Azure?
Article • 08/28/2024

Spring Cloud Azure is an open source project that helps make it easier to use Azure
services in Spring applications.

Spring Cloud Azure is an open source project, with all resources available to the public.
The following list provides links to these resources:

Source code: Azure/azure-sdk-for-java .

Samples: Azure-Samples/azure-spring-boot-samples .
Documentation: Spring Cloud Azure.

What is Spring Cloud Azure used for?

Spring Cloud Azure can help make it easier to accomplish the following tasks in Spring
applications:

Managing configuration properties with Azure App Configuration.

Sending and receiving messages with Azure Event Hubs, Azure Service Bus, and
Azure Storage Queue.
Managing secrets and certificates with Azure Key Vault.
Supporting user sign-in with work or school accounts provisioned with Microsoft
Entra ID.
Supporting user sign-in with social accounts like Facebook and Google with Azure
Active Directory B2C.
Protecting your web APIs and accessing protected APIs like Microsoft Graph to
work with your users' and organization's data with Microsoft Entra ID and Azure
Active Directory B2C.
Storing structured data with Azure Cosmos DB.
Storing unstructured data like text or binary data with Azure Blob Storage.
Storing files with Azure Files.

Benefits of using Spring Cloud Azure

The following section demonstrates the benefits of using Spring Cloud Azure. In this
section, the retrieval of secrets stored in Azure Key Vault is used as an example. This
section compares the differences between developing a Spring Boot application with
and without Spring Cloud Azure.
Without Spring Cloud Azure
Without Spring Cloud Azure, if you want to retrieve secrets stored in Azure Key Vault,
you need to the following steps:

1. Add the following dependencies to your pom.xml file:

XML

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-security-keyvault-secrets</artifactId>
<version>4.5.2</version>
</dependency>

2. Construct a SecretClient class instance by using code similar to the following

example:

Java

public class DemoClass {

public static void main(String... args) {
SecretClient client = new SecretClientBuilder()
.vaultUrl("vaultUrl")
.credential(new ClientSecretCredentialBuilder()
.tenantId("tenantId")
.clientId("clientId")
.clientSecret("clientSecret")
.build())
.buildClient();
}
}

3. Avoid hard coding information such as client-id and client-secret by making

these properties configurable, as shown in the following example:

Java

@ConfigurationProperties("azure.keyvault")
public class KeyVaultProperties {
private String vaultUrl;
private String tenantId;
private String clientId;
private String clientSecret;

public KeyVaultProperties(String vaultUrl, String tenantId, String

clientId, String clientSecret) {
this.vaultUrl = vaultUrl;
this.tenantId = tenantId;
 this.clientId = clientId;
this.clientSecret = clientSecret;
}

public String getVaultUrl() {

return vaultUrl;
}

public void setVaultUrl(String vaultUrl) {

this.vaultUrl = vaultUrl;
}

public String getTenantId() {

return tenantId;
}

public void setTenantId(String tenantId) {

this.tenantId = tenantId;
}

public String getClientId() {

return clientId;
}

public void setClientId(String clientId) {

this.clientId = clientId;
}

public String getClientSecret() {

return clientSecret;
}

public void setClientSecret(String clientSecret) {

this.clientSecret = clientSecret;
}
}

4. Update your application code as shown in this example:

Java

@SpringBootApplication
@EnableConfigurationProperties(KeyVaultProperties.class)
public class SecretClientApplication implements CommandLineRunner {
private KeyVaultProperties properties;

public SecretClientApplication(KeyVaultProperties properties) {

this.properties = properties;
}

public static void main(String[] args) {

SpringApplication.run(SecretClientApplication.class, args);
}
 @Override
public void run(String... args) {
SecretClient client = new SecretClientBuilder()
.vaultUrl(properties.getVaultUrl())
.credential(new ClientSecretCredentialBuilder()
.tenantId(properties.getTenantId())
.clientId(properties.getClientId())
.clientSecret(properties.getClientSecret())
.build())
.buildClient();
System.out.println("sampleProperty: " +
client.getSecret("sampleProperty").getValue());
}
}

5. Add the necessary properties to your application.yml file, as shown in the following
example:

YAML

azure:
keyvault:
vault-url:
tenant-id:
client-id:
client-secret:

6. If you need to use SecretClient in multiple places, define a SecretClient bean.

Then, auto-wire SecretClient in the relevant places.

With Spring Cloud Azure

With Spring Cloud Azure, if you want to retrieve secrets stored in Azure Key Vault, the
requirements are simpler, as shown in the following steps:

1. Add the following dependencies to your pom.xml file:

XML

<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-keyvault-
secrets</artifactId>
</dependency>
</dependencies>
2. Use a bill of materials (BOM) to manage the Spring Cloud Azure version, as shown
in the following example:

XML

<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-dependencies</artifactId>
<version>5.15.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

７ Note

If you're using Spring Boot 2.x, be sure to set the spring-cloud-azure-

dependencies version to 4.19.0 . This Bill of Material (BOM) should be

configured in the <dependencyManagement> section of your pom.xml file. This

ensures that all Spring Cloud Azure dependencies are using the same version.
For more information about the version used for this BOM, see Which Version
of Spring Cloud Azure Should I Use .

3. Add the following properties to your application.yml file:

YAML

spring:
cloud:
azure:
keyvault:
secret:
endpoint:

4. Sign in with Azure CLI by using the following command. Your credentials will then
be provided by Azure CLI, so there will be no need to add other credential
information such as client-id and client-secret .

Azure CLI

az login
 5. Auto-wire SecretClient in the relevant places, as shown in the following example:

Java

@SpringBootApplication
public class SecretClientApplication implements CommandLineRunner {

private final SecretClient secretClient;

public SecretClientApplication(SecretClient secretClient) {

this.secretClient = secretClient;
}

public static void main(String[] args) {

SpringApplication.run(SecretClientApplication.class, args);
}

@Override
public void run(String... args) {
System.out.println("sampleProperty: " +
secretClient.getSecret("sampleProperty").getValue());
}
}

Spring Cloud Azure will provide some other features besides the auto-configured
SecretClient . For example, you can use @Value to get the secret value, as shown in the
following example:

Java

@SpringBootApplication
public class PropertySourceApplication implements CommandLineRunner {

@Value("${sampleProperty1}")
private String sampleProperty1;

public static void main(String[] args) {

SpringApplication.run(PropertySourceApplication.class, args);
}

public void run(String[] args) {

System.out.println("sampleProperty1: " + sampleProperty1);
}

Components of Spring Cloud Azure

Azure support
Provides auto-configuration support for Azure Services, such as Service Bus, Storage,
Active Directory, and so on.

Microsoft Entra ID
Provides integration support for Spring Security with Microsoft Entra ID for
authentication. For more information, see Spring Cloud Azure support for Spring
Security.

Azure Key Vault

Provides Spring @Value annotation support for integration with Azure Key Vault Secrets.
For more information, see Spring Cloud Azure secret management.

Azure Storage
Provides Spring Boot support for Azure Storage services. For more information, see
Spring Cloud Azure resource handling.

Get support
If you need support for Spring Cloud Azure, you can ask for help in the following ways:

Create Azure support tickets. Customers with an Azure support plan can open an
Azure support ticket . We recommend this option if your problem requires
immediate attention.
File GitHub issues in the Azure/azure-sdk-for-java repository . We use GitHub
issues to track bugs, questions, and feature requests. GitHub issues are free, but
the response time isn't guaranteed. For more information, see GitHub issues
support process .

Next steps
Tutorial: Read a secret from Azure Key Vault in a Spring Boot application
Secure REST API using Spring Security 5 and Microsoft Entra ID
How to use the Spring Boot Starter with Azure Cosmos DB for NoSQL
Feedback
Was this page helpful?  Yes  No

Get help at Microsoft Q&A

Troubleshooting overview for the Azure
SDK for Java
Article • 02/14/2025

This article introduces many troubleshooting tools available to you when you use the
Azure SDK for Java, and links to other articles with further details.

The Azure SDK for Java consists of many client libraries - one or more for each Azure
Service that exists. We ensure that all client libraries are built to a consistent, high
standard, with common patterns for configuration, logging, exception handling, and
troubleshooting. For more information, see Use the Azure SDK for Java.

Because troubleshooting can span such a wide subject area, we've developed the
following troubleshooting guides that you may want to review:

Troubleshoot Azure Identity authentication issues covers authentication failure

investigation techniques, common errors for the credential types in the Azure
Identity Java client library, and mitigation steps to resolve these errors.
Troubleshoot dependency version conflicts covers subjects related to diagnosing,
mitigating, and minimizing dependency conflicts. These conflicts can arise when
you use the Azure SDK for Java client libraries in systems that are built with tools
such as Maven and Gradle.
Troubleshoot networking issues covers subjects related to HTTP debugging
outside of the client library, using tools like Fiddler and Wireshark.

Along with these general troubleshooting guides, we also provide library-specific

troubleshooting guides. Right now, the following guides are available:

Troubleshoot Azure Event Hubs

Troubleshoot Azure Service Bus

Beyond these documents, the following content provides guidance on making the best
use of logging and exception handling as it relates to the Azure SDK for Java.

Use logging in the Azure SDK for Java

The following sections describe how to enable different kinds of logging.

Enable client logging

To troubleshoot issues, it's important to first enable logging to monitor the behavior of
your application. The errors and warnings in the logs generally provide useful insights
into what went wrong and sometimes include corrective actions to fix issues. The Azure
SDK for Java has comprehensive logging support. For more information, see Configure
logging in the Azure SDK for Java.

Enable HTTP request/response logging

When troubleshooting issues, it's useful to review HTTP requests as they're sent and
received between Azure services. To enable logging the HTTP request and response
payload, you can configure almost all Azure SDK for Java client libraries in their client
builders as shown in the following example. In particular, pay special attention to the
httpLogOptions method on the client builder, and the enum values available in
HttpLogDetailLevel .

Java

ConfigurationClient configurationClient = new ConfigurationClientBuilder()

.connectionString(connectionString)
.httpLogOptions(new
HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
.buildClient();

This code changes the HTTP request/response logging for a single client instance.
Alternatively, you can configure logging HTTP requests and responses for your entire
application by setting the AZURE_HTTP_LOG_DETAIL_LEVEL environment variable to one of
the values in the following table. It's important to note that this change enables logging
for every Azure client that supports logging HTTP request/response.

ﾉ Expand table

Value Logging level

none HTTP request/response logging is disabled.

basic Logs only URLs, HTTP methods, and time to finish the request.

headers Logs everything in BASIC, plus all the request and response headers.

body Logs everything in BASIC, plus all the request and response body.

body_and_headers Logs everything in HEADERS and BODY.

７ Note
 When you log request and response bodies, ensure that they don't contain
confidential information. When you log query parameters and headers, the client
library has a default set of query parameters and headers that are considered safe
to log. It's possible to add additional query parameters and headers that are safe to
log, as shown in the following example:

Java

clientBuilder.httpLogOptions(new HttpLogOptions()
.addAllowedHeaderName("safe-to-log-header-name")
.addAllowedQueryParamName("safe-to-log-query-parameter-name"))

Exception handling in the Azure SDK for Java

Most Azure SDK for Java client service methods throw an HttpResponseException or a
more-specific subclass on failure. The HttpResponseException type includes a detailed
response error object that provides specific useful insights into what went wrong and
includes corrective actions to fix common issues. You can find this error information
inside the message property of the HttpResponseException object. Because these
exceptions are runtime exceptions, the JavaDoc reference documentation doesn't
explicitly call them out.

The following example shows you how to catch this exception with a synchronous client:

Java

try {
ConfigurationSetting setting = new
ConfigurationSetting().setKey("myKey").setValue("myValue");
client.getConfigurationSetting(setting);
} catch (HttpResponseException e) {
System.out.println(e.getMessage());
// Do something with the exception
}

With asynchronous clients, you can catch and handle exceptions in the error callbacks,
as shown in the following example:

Java

ConfigurationSetting setting = new

ConfigurationSetting().setKey("myKey").setValue("myValue");
asyncClient.getConfigurationSetting(setting)
.doOnSuccess(ignored -> System.out.println("Success!"))
 .doOnError(
error -> error instanceof ResourceNotFoundException,
error -> System.out.println("Exception: 'getConfigurationSetting'
could not be performed."));

Use tracing in the Azure SDK for Java

The Azure SDK for Java offers comprehensive tracing support, enabling you to see the
flow of execution through your application code and the client libraries you're using.
You can enable tracing in Azure client libraries by using and configuring the
OpenTelemetry SDK or by using an OpenTelemetry-compatible agent. OpenTelemetry
is a popular open-source observability framework for generating, capturing, and
collecting telemetry data for cloud-native software.

For more information on how to enable tracing in the Azure SDK for Java, see Configure
tracing in the Azure SDK for Java.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot Azure Identity
authentication issues
Article • 04/02/2025

This article covers failure investigation techniques, common errors for the credential
types in the Azure Identity Java client library, and mitigation steps to resolve these
errors. Because there are many credential types available in the Azure SDK for Java,
we've split the troubleshooting guide into sections based on usage scenario. The
following sections are available:

Troubleshoot Azure-hosted application authentication

Troubleshoot development environment authentication
Troubleshoot service principal authentication
Troubleshoot multi-tenant authentication

The remainder of this article covers general troubleshooting techniques and guidance
that apply to all credential types.

Handle Azure Identity exceptions

As noted in the Exception handling in the Azure SDK for Java section of Troubleshooting
overview, there's a comprehensive set of exceptions and error codes that the Azure SDK
for Java can throw. For Azure Identity specifically, there are a few key exception types
that are important to understand.

ClientAuthenticationException
Any service client method that makes a request to the service can raise exceptions
arising from authentication errors. These exceptions are possible because the token is
requested from the credential on the first call to the service and on any subsequent
requests to the service that need to refresh the token.

To distinguish these failures from failures in the service client, Azure Identity classes raise
ClientAuthenticationException with details describing the source of the error in the

exception message and possibly the error message. Depending on the application, these
errors may or may not be recoverable. The following code shows an example of catching
ClientAuthenticationException :

Java
 // Create a secret client using the DefaultAzureCredential
SecretClient client = new SecretClientBuilder()
.vaultUrl("https://myvault.vault.azure.net/")
.credential(new DefaultAzureCredentialBuilder().build())
.buildClient();

try {
KeyVaultSecret secret = client.getSecret("secret1");
} catch (ClientAuthenticationException e) {
//Handle Exception
e.printStackTrace();
}

CredentialUnavailableException
CredentialUnavailableException is a special exception type derived from

ClientAuthenticationException . This exception type is used to indicate that the

credential can't authenticate in the current environment due to lack of required

configuration or setup. This exception is also used as a signal to chained credential
types, such as DefaultAzureCredential and ChainedTokenCredential , that the chained
credential should continue to try other credential types later in the chain.

Permission issues
Calls to service clients resulting in HttpResponseException with a StatusCode of 401 or
403 often indicate the caller doesn't have sufficient permissions for the specified API.
Check the service documentation to determine which roles are needed for the specific
request. Ensure that the authenticated user or service principal has been granted the
appropriate roles on the resource.

Find relevant information in exception

messages
ClientAuthenticationException is thrown when unexpected errors occur while a

credential is authenticating. These errors can include errors received from requests to
the Microsoft Entra security token service (STS) and often contain information helpful to
diagnosis. Consider the following ClientAuthenticationException message:

Output

ClientSecretCredential authentication failed: A configuration issue is

preventing authentication - check the error message from the server for
 details. You can modify the configuration in the application registration
portal. See https://aka.ms/msal-net-invalid-client for details.

Original exception:
AADSTS7000215: Invalid client secret provided. Ensure the secret being sent
in the request is the client secret value, not the client secret ID, for a
secret added to app 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.
Trace ID: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
Correlation ID: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
Timestamp: 2022-01-01 00:00:00Z

This error message contains the following information:

Failing credential type: The type of credential that failed to authenticate - in this
case, ClientSecretCredential . This information is helpful when diagnosing issues
with chained credential types, such as DefaultAzureCredential or
ChainedTokenCredential .

STS error code and message: The error code and message returned from the
Microsoft Entra STS - in this case, AADSTS7000215: Invalid client secret
provided. This information can give insight into the specific reason the request

failed. For instance, in this specific case, because the provided client secret is
incorrect. For more information on STS error codes, see the AADSTS error codes
section of Microsoft Entra authentication and authorization error codes.

Correlation ID and timestamp: The correlation ID and call timestamp used to

identify the request in server-side logs. This information is useful to support
engineers when diagnosing unexpected STS failures.

Enable and configure logging

Azure SDK for Java offers a consistent logging story to help in troubleshooting
application errors and to help expedite their resolution. The logs produced capture the
flow of an application before reaching the terminal state to help locate the root issue.
For guidance on logging, see Configure logging in the Azure SDK for Java and
Troubleshooting over view.

The underlying MSAL library, MSAL4J , also has detailed logging. This logging is highly
verbose and includes all personal data including tokens. This logging is most useful
when working with product support. As of v1.10.0, credentials that offer this logging
have a method called enableUnsafeSupportLogging() .

Ｕ Caution
 Requests and responses in the Azure Identity library contain sensitive information.
You must take precautions to protect logs when customizing the output to avoid
compromising account security.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot Azure-hosted application
authentication
Article • 04/02/2025

This article provides guidance on dealing with issues encountered when authenticating
Azure SDK for Java applications hosted on Azure, through various TokenCredential
implementations. For more information, see Authenticate Azure-hosted Java
applications.

Troubleshoot DefaultAzureCredential
When you use DefaultAzureCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

CredentialUnavailableException All credentials in the Enable logging to verify the

raised with message DefaultAzureCredential chain credentials being tried, and
"DefaultAzureCredential failed failed to retrieve a token, each get further diagnostic
to retrieve a token from the throwing a information.
included credentials." CredentialUnavailableException .
For more information, see
the troubleshooting guide
for one of the following
underlying credential types:
- EnvironmentCredential
-
ManagedIdentityCredential
-
VisualStudioCodeCredential
- AzureCLICredential
-
AzurePowershellCredential

HttpResponseException raised Authentication succeeded but Enable logging to

from the client with a status the authorizing Azure service determine which credential
code of 401 or 403 responded with a 401 in the chain returned the
(Authenticate), or 403 authenticating token.
(Forbidden) status code. This
issue often occurs when In the case where a
DefaultAzureCredential credential other than the
 Error message Description Mitigation

authenticates an account other expected one is returning a

than the intended one or the token, look to bypass this
intended account doesn't have issue by signing out of the
the correct permissions or roles corresponding
assigned. development tool.

Ensure that the correct role

is assigned to the account
being used. For example, a
service-specific role rather
than the subscription
Owner role.

Troubleshoot EnvironmentCredential
When you use EnvironmentCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

Environment A valid Ensure that the appropriate environment variables are set
variables combination of prior to application startup for the intended
aren't fully environment authentication method, as described in the following list:
configured. variables wasn't - To authenticate a service principal using a client secret,
set. ensure that the variables AZURE_CLIENT_ID ,
AZURE_TENANT_ID , and AZURE_CLIENT_SECRET are properly
set.
- To authenticate a service principal using a certificate,
ensure that the variables AZURE_CLIENT_ID ,
AZURE_TENANT_ID , AZURE_CLIENT_CERTIFICATE_PATH , and
optionally AZURE_CLIENT_CERTIFICATE_PASSWORD are
properly set.
- To authenticate a user using a password, ensure that the
variables AZURE_USERNAME and AZURE_PASSWORD are
properly set.

Troubleshoot ManagedIdentityCredential
ManagedIdentityCredential is designed to work on various Azure hosts that provide

managed identity. Configuring the managed identity and troubleshooting failures varies
from host to host. The following list shows the Azure host environments that you can
assign a managed identity and that ManagedIdentityCredential supports:

Azure App Service and Azure Functions - configuration - troubleshooting

Azure Arc - configuration
Azure Kubernetes Service - configuration - troubleshooting
Azure Service Fabric -configuration
Azure Virtual Machines and Scale Sets -configuration - troubleshooting

Azure Virtual Machine Managed Identity

When you use ManagedIdentityCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

The requested The Azure Instance If you're using a user-assigned identity, ensure
identity hasn't Metadata Service (IMDS) that the specified clientId is correct.
been assigned to endpoint responded with a
this resource. status code of 400, If you're using a system assigned identity, make
indicating the requested sure that you've enabled it properly. For more
identity isn't assigned to information, see the Enable system-assigned
the virtual machine (VM). managed identity on an existing VM section of
Configure managed identities for Azure
resources on a VM using the Azure portal.

The request The request to the IMDS IMDS doesn't support calls via proxy or gateway.
failed due to a endpoint failed due to a Disable proxies or gateways running on the VM
gateway error. gateway error, 502 or 504 for calls to the IMDS endpoint
status code. http://169.254.169.254/

No response No response was received - Ensure that you've properly configured

received from for the request to IMDS or managed identity on the VM. For more
the managed the request timed out. information, see Configure managed identities
identity for Azure resources on a VM using the Azure
endpoint. portal.
- Verify that the IMDS endpoint is reachable on
the VM. For more information, see the next
section.

Multiple Retries to retrieve a token - For more information on specific failures, see
attempts failed from the IMDS endpoint the inner exception messages. If the data has
to obtain a have been exhausted. been truncated, more detail can be obtained by
token from the collecting logs.
 Error message Description Mitigation

managed identity - Ensure that you've properly configured

endpoint. managed identity on the VM. For more
information, see Configure managed identities
for Azure resources on a VM using the Azure
portal.
- Verify that the IMDS endpoint is reachable on
the VM. For more information, see the next
section.

Verify that IMDS is available on the VM

If you have access to the VM, you can verify that the manged identity endpoint is
available via the command line using curl , as shown in the following example:

Bash

curl 'http://169.254.169.254/metadata/identity/oauth2/token?
resource=https://management.core.windows.net&api-version=2018-02-01' -H
"Metadata: true"

２ Warning

The output of this command contains a valid access token. To avoid compromising
account security, don't share this access token.

Azure App Service and Azure Functions Managed Identity

When you use ManagedIdentityCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

ManagedIdentityCredential The environment - Ensure that you've properly

authentication unavailable. variables configured configured the managed identity on
by the App Services the App Service instance. For more
host weren't present. information, see How to use managed
identities for App Service and Azure
Functions.
- Verify that you've properly
 Error message Description Mitigation

configured the App Service

environment and that the managed
identity endpoint is available. For
more information, see the next
section.

Verify that the App Service Managed Identity endpoint is available

If you have access to SSH into the App Service instance, you can verify that managed
identity is available in the environment. Use curl to validate that the managed identity
is available, as shown in the following example:

Bash

curl "$IDENTITY_ENDPOINT?resource=https://management.core.windows.net&api-
version=2019-08-01" -H "X-IDENTITY-HEADER: $IDENTITY_HEADER"

２ Warning

The output of this command contains a valid access token. To avoid compromising
account security, don't share this access token.

Azure Kubernetes Service Managed Identity

Pod Identity for Kubernetes

When you use ManagedIdentityCredential , you can optionally try/catch for

CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error Description Mitigation

message

No Managed The application Verify that the pod is labeled correctly. This problem also
Identity attempted to occurs when a correctly labeled pod authenticates before
endpoint authenticate before the identity is ready. To prevent initialization races,
found an identity was configure NMI to set the Retry-After header in its
assigned to its pod. responses. For more information, see Set Retry-After
 Error Description Mitigation
message

header in NMI response in the Pod Identity

documentation.

Troubleshoot WorkloadIdentityCredential
When you use WorkloadIdentityCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

WorkloadIdentityCredential WorkloadIdentityCredential If you're using

authentication unavailable. requires clientId , tenantId DefaultAzureCredential , then:
The workload options aren't and tokenFilePath to - Ensure that the client ID is
fully configured. authenticate with Microsoft specified via the
Entra ID. workloadIdentityClientId
setter or the AZURE_CLIENT_ID
environment variable.
- Ensure that the tenant ID is
specified via the
AZURE_TENANT_ID environment
variable.
- Ensure that you've specified
the token file path via the
AZURE_FEDERATED_TOKEN_FILE
environment variable.
- Ensure that the authority host
is specified via the
AZURE_AUTHORITY_HOST
environment variable.

If you're using
WorkloadIdentityCredential ,
then:
- Ensure that the tenant ID is
specified via the tenantId
setter on the credential builder
or the AZURE_TENANT_ID
environment variable.
- Ensure that the client ID is
specified via the clientId
setter on the credential builder
 Error message Description Mitigation

or the AZURE_CLIENT_ID
environment variable.
- Ensure that the token file path
is specified via the
tokenFilePath setter on the
credential builder or the
AZURE_FEDERATED_TOKEN_FILE
environment variable.
- For other issues, see the
product troubleshooting
guide .

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot development environment
authentication
Article • 04/02/2025

This article provides guidance on dealing with issues encountered when authenticating
Azure SDK for Java applications running locally on developer machines, through various
TokenCredential implementations. For more information, see Azure authentication in

Java development environments.

Troubleshoot AzureCliCredential
When you use AzureCliCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

Azure CLI not The Azure CLI isn't installed or - Ensure that you've properly installed
installed couldn't be found. the Azure CLI.
- Validate that the installation location
has been added to the PATH
environment variable.

Please run 'az No account is currently signed - Sign in to the Azure CLI using the az
login' to set up into the Azure CLI, or the sign- login command. For more information,
account in has expired. see Sign in with Azure CLI.
- Validate that the Azure CLI can obtain
tokens. For more information, see the
next section.

Verify that the Azure CLI can obtain tokens

You can manually verify that you've properly authenticated the Azure CLI and can obtain
tokens. First, use the following command to verify that the account is currently signed in
to the Azure CLI:

Azure CLI

az account show
After you've verified the Azure CLI is using correct account, use the following command
to validate that it's able to obtain tokens for this account:

Azure CLI

az account get-access-token \
--output json \
--resource https://management.core.windows.net

２ Warning

The output of this command contains a valid access token. To avoid compromising
account security, don't share this access token.

Troubleshoot AzureDeveloperCliCredential
When you use AzureDeveloperCliCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

Azure Developer CLI The Azure Developer CLI isn't - Ensure that you've properly installed
not installed installed or couldn't be found. the Azure Developer CLI.
- Validate that the installation location
has been added to the PATH
environment variable.

Please run 'azd No account is currently signed in - Sign in to the Azure Developer CLI
auth login' to set to the Azure Developer CLI, or using the azd auth login command.
up account the sign-in has expired. - Validate that the Azure Developer
CLI can obtain tokens. For more
information, see the next section.

Verify that the Azure Developer CLI can obtain tokens

You can manually verify that you've properly authenticated the Azure Developer CLI, and
can obtain tokens. First, use the following command to verify that the account is
currently signed in to the Azure Developer CLI:

Bash
 azd config list

After you've verified the Azure Developer CLI is using correct account, you can use the
following command to validate that it's able to obtain tokens for this account:

Bash

azd auth token --output json --scope

https://management.core.windows.net/.default

２ Warning

The output of this command contains a valid access token. To avoid compromising
account security, don't share this access token.

Troubleshoot AzurePowerShellCredential
When you use AzurePowerShellCredential , you can optionally try/catch for
CredentialUnavailableException . The following table shows the errors that this

exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

PowerShell isn't No local installation of Ensure that you've properly installed

installed. PowerShell was found. PowerShell on the machine.

Az.Account module The Az.Account module Install the latest Az.Account module.
>= 2.2.0 isn't needed for authentication in For more information, see How to
installed. Azure PowerShell isn't installed. install Azure PowerShell.

Please run No account is currently signed - Sign in to Azure PowerShell using the
'Connect-AzAccount' in to Azure PowerShell. Connect-AzAccount command. For more
to set up account. information, see Sign in with Azure
PowerShell
- Validate that Azure PowerShell can
obtain tokens. For more information,
see the next section.

Verify that Azure PowerShell can obtain tokens

You can manually verify that you've properly authenticated Azure PowerShell, and can
obtain tokens. First, use the following command to verify that the account is currently
signed in to the Azure CLI:

PowerShell

Get-AzContext

This command produces output similar to the following example:

Output

Name Account
SubscriptionName Environment TenantId
---- ------- ---------------
- ----------- --------
Subscription1 (xxxxxxxx-xxxx-xxxx-xxx... test@outlook.com Subscription1
AzureCloud xxxxxxxx-x...

After you've verified Azure PowerShell is using correct account, you can use the
following command to validate that it's able to obtain tokens for this account.

PowerShell

Get-AzAccessToken -ResourceUrl "https://management.core.windows.net"

２ Warning

The output of this command contains a valid access token. To avoid compromising
account security, don't share this access token.

Troubleshoot VisualStudioCodeCredential

７ Note

It's a known issue that VisualStudioCodeCredential doesn't work with Azure

Account extension versions newer than 0.9.11 . A long-term fix to this problem
is in progress. In the meantime, consider authenticating via the Azure CLI .

When you use VisualStudioCodeCredential , you can optionally try/catch for

CredentialUnavailableException . The following table shows the errors that this
exception indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

Failed To Read VS Code No Azure account information was - Ensure that you've
Credentials</p> found in the VS Code properly installed the Azure
</p>OR</p>Authenticate via configuration. Account plugin .
Azure Tools plugin in VS - Use View > Command
Code Palette to execute the
Azure: Sign In command.
This command opens a
browser window and
displays a page that allows
you to sign in to Azure.
- If you already have the
Azure Account extension
installed and have signed in
to your account, try logging
out and logging in again.
This action repopulates the
cache and potentially
mitigates the error you're
getting.

MSAL Interaction Required VisualStudioCodeCredential was Sign in to the Azure Account

Exception able to read the cached credentials extension via View >
from the cache but the cached Command Palette to
token is likely expired. execute the Azure: Sign In
command in the VS Code
IDE.

ADFS tenant not supported Visual Studio Azure Service Use credentials from a
Authentication doesn't currently supported cloud when
support ADFS tenants. authenticating with Visual
Studio. For more
information about the
supported clouds, see
National clouds.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot service principal
authentication
Article • 04/02/2025

This article provides guidance on dealing with issues encountered when authenticating
Azure SDK for Java applications via service principal, through various TokenCredential
implementations. For more information, see Azure authentication with service principal.

Troubleshoot ClientSecretCredential
When you use ClientSecretCredential , you can optionally try/catch for
ClientAuthenticationException . The following table shows the errors that this exception

indicates, and methods of mitigation:

ﾉ Expand table

Error code Issue Mitigation

AADSTS7000215 An invalid client Ensure that the clientSecret provided when constructing
secret was the credential is valid. If unsure, create a new client secret
provided. using the Azure portal. For more information, see the
Create a new application secret section of Create a
Microsoft Entra application and service principal that can
access resources.

AADSTS7000222 An expired client Create a new client secret using the Azure portal. For more
secret was information, see the Create a new application secret
provided. section of Create a Microsoft Entra application and service
principal that can access resources.

AADSTS700016 The specified Ensure the specified clientId and tenantId are correct for
application wasn't your application registration. For multi-tenant apps, ensure
found in the that a tenant admin has added the application to the
specified tenant. desired tenant. For more information, see Create a
Microsoft Entra application and service principal that can
access resources.

Troubleshoot ClientCertificateCredential
When you use ClientCertificateCredential , you can optionally try/catch for
ClientAuthenticationException . The following table shows the errors that this exception

indicates, and methods of mitigation:

 ﾉ Expand table

Error code Description Mitigation

AADSTS700027 Client assertion Ensure that you've uploaded the specified certificate to the
contains an invalid Microsoft Entra application registration. For more
signature. information, see the Upload a trusted certificate issued by
a certificate authority section of Create a Microsoft Entra
application and service principal that can access resources.

AADSTS700016 The specified Ensure that the specified clientId and tenantId are
application wasn't correct for your application registration. For multi-tenant
found in the apps, ensure that a tenant admin has added the
specified tenant. application to the desired tenant. For more information,
see Create a Microsoft Entra application and service
principal that can access resources.

Troubleshoot ClientAssertionCredential
When you use ClientAssertionCredential , you can optionally try/catch for
ClientAuthenticationException . The following table shows the errors that this exception

indicates, and methods of mitigation:

ﾉ Expand table

Error code Description Mitigation

AADSTS700021 The client Ensure that the JWT assertion created has the correct values
assertion specified for the sub and issuer value of the payload. Both of
application these fields should be equal to clientId . For the client
identifier assertion format, see Microsoft identity platform application
doesn't match authentication certificate credentials.
the client_id
parameter.

AADSTS700023 The client Ensure that the audience aud field in the JWT assertion created
assertion has the correct value for the audience specified in the payload.
audience claim Set this field to
doesn't match https://login.microsoftonline.com/{tenantId}/v2 .
the Realm
issuer.

AADSTS50027 JWT token is Ensure that the JWT assertion token is in the valid format. For
invalid or more information, see Microsoft identity platform application
malformed. authentication certificate credentials.
Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot multi-tenant
authentication
Article • 04/02/2025

This article provides guidance on dealing with issues encountered in a multi-tenant

context.

When you use credentials in a multi-tenant context, you can optionally try/catch for
ClientAuthenticationException . The following table shows the errors that this exception

indicates, and methods of mitigation:

ﾉ Expand table

Error message Description Mitigation

The current The application must Add the requested tenant ID to

credential is not configure the additionallyAllowedTenants on the credential
configured to credential to allow builder, or add "*" to additionallyAllowedTenants
acquire tokens for acquiring tokens to allow acquiring tokens for any tenant.
tenant <tenant-ID> from the requested
tenant. This exception was added as part of a breaking
change to multi-tenant authentication in version
1.6.0 . Users experiencing this error after
upgrading can find information about the change
and migration in BREAKING_CHANGES.md

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot Azure Event Hubs
Article • 04/02/2025

This article covers failure investigation techniques, common errors for the credential
types in the Event Hubs library, and mitigation steps to resolve these errors. In addition
to the general troubleshooting techniques and guidance that apply regardless of the
Event Hubs use case, the following articles cover specific features of the Event Hubs
library:

Troubleshoot Azure Event Hubs producer

Troubleshoot Azure Event Hubs event processor
Troubleshoot Azure Event Hubs performance

The remainder of this article covers general troubleshooting techniques and guidance
that apply to all users of the Event Hubs library.

Handle Event Hubs exceptions

All Event Hubs exceptions are wrapped in an AmqpException. These exceptions often
have an underlying AMQP error code that specifies whether an error should be retried.
For retryable errors (that is, amqp:connection:forced or amqp:link:detach-forced ), the
client libraries attempt to recover from these errors based on the retry options specified
when instantiating the client. To configure retry options, follow the sample publish
events to specific partition . If the error is nonretryable, there's some configuration
issue that needs to be resolved.

The recommended way to solve the specific exception the AMQP exception represents
is to follow the Event Hubs Messaging Exceptions guidance.

Find relevant information in exception messages

An AmqpException contains the following three fields, which describe the error:

getErrorCondition: The underlying AMQP error. For a description of the errors, see
the AmqpErrorCondition Enum documentation or the OASIS AMQP 1.0 spec .
isTransient: A value that indicates whether trying to perform the same operation is
possible. SDK clients apply the retry policy when the error is transient.
getErrorContext: Contains the following information about where the AMQP error
originated:
LinkErrorContext: Errors that occur in either the send or receive link.
SessionErrorContext: Errors that occur in the session.
 AmqpErrorContext: Errors that occur in the connection or a general AMQP error.

Commonly encountered exceptions

amqp:connection:forced and amqp:link:detach-forced

When the connection to Event Hubs is idle, the service disconnects the client after some
time. This issue isn't a problem because the clients re-establish a connection when a
service operation is requested. For more information, see AMQP errors in Azure Service
Bus.

Permission issues
An AmqpException with an AmqpErrorCondition of amqp:unauthorized-access means
that the provided credentials don't allow for performing the action (receiving or
sending) with Event Hubs. To resolve this issue, try the following tasks:

Double check that you have the correct connection string. For more information,
see Get an Event Hubs connection string.
Ensure that your shared access signature (SAS) token is generated correctly. For
more information, see Authorizing access to Event Hubs resources using Shared
Access Signatures.

For other possible solutions, see Troubleshoot authentication and authorization issues
with Event Hubs.

Connectivity issues

Timeout when connecting to service

To resolve timeout issues, try the following tasks:

Verify that the connection string or fully qualified domain name specified when
creating the client is correct. For more information, see Get an Event Hubs
connection string.
Check the firewall and port permissions in your hosting environment and verify
that the AMQP ports 5671 and 5762 are open.
Make sure that the endpoint is allowed through the firewall.
Try using WebSockets, which connects on port 443. For more information, see the
PublishEventsWithWebSocketsAndProxy.java sample.
 See if your network is blocking specific IP addresses. For more information, see
What IP addresses do I need to allow?
If applicable, check the proxy configuration. For more information, see the
PublishEventsWithWebSocketsAndProxy.java sample.
For more information about troubleshooting network connectivity, see
Troubleshoot connectivity issues - Azure Event Hubs.

TLS/SSL handshake failures

This error can occur when an intercepting proxy is used. To verify, we recommend
testing in your hosting environment with the proxy disabled.

Socket exhaustion errors

Applications should prefer treating the Event Hubs clients as a singleton, creating and
using a single instance through the lifetime of their application. This recommendation is
important because each client type manages its connection. When you create a new
Event Hubs client, it results in a new AMQP connection, which uses a socket.
Additionally, it's essential that clients inherit from java.io.Closeable , so your
application is responsible for calling close() when it's finished using a client.

To use the same AMQP connection when creating multiple clients, you can use the
EventHubClientBuilder.shareConnection() flag, hold a reference to that

EventHubClientBuilder , and create new clients from that same builder instance.

Connect using an IoT connection string

Because translating a connection string requires querying the IoT Hub service, the Event
Hubs client library can't use it directly. The IoTConnectionString.java sample describes
how to query IoT Hub to translate an IoT connection string into one that can be used
with Event Hubs.

For more information, see the following articles:

Control access to IoT Hub using Shared Access Signatures

Read device-to-cloud messages from the built-in endpoint

Can't add components to the connection string

The legacy Event Hubs clients allowed customers to add components to the connection
string retrieved from the Azure portal. The legacy clients are in packages
com.microsoft.azure:azure-eventhubs and com.microsoft.azure:azure-eventhubs-
eph . The current generation supports connection strings only in the form published
by the Azure portal.

Add "TransportType=AmqpWebSockets"
To use web sockets, see the PublishEventsWithSocketsAndProxy.java sample.

Add "Authentication=Managed Identity"

To authenticate with Managed Identity, see the sample
PublishEventsWithAzureIdentity.java .

For more information about the Azure.Identity library, check out our Authentication
and the Azure SDK blog post.

Enable and configure logging

Azure SDK for Java offers a consistent logging story to help in troubleshooting
application errors and to help expedite their resolution. The logs produced capture the
flow of an application before reaching the terminal state to help locate the root issue.
For guidance on logging, see Configure logging in the Azure SDK for Java and
Troubleshooting overview.

In addition to enabling logging, setting the log level to VERBOSE or DEBUG provides
insights into the library's state. The following sections show sample log4j2 and logback
configurations to reduce the excessive messages when verbose logging is enabled.

Configure Log4J 2
Use the following steps to configure Log4J 2:

1. Add the dependencies in your pom.xml using the ones from the logging sample
pom.xml , in the "Dependencies required for Log4j2" section.
2. Add log4j2.xml to your src/main/resources folder.

Configure logback
Use the following steps to configure logback:
 1. Add the dependencies in your pom.xml using the ones from the logging sample
pom.xml , in the "Dependencies required for logback" section.
2. Add logback.xml to your src/main/resources folder.

Enable AMQP transport logging

If enabling client logging isn't enough to diagnose your issues, you can enable logging
to a file in the underlying AMQP library, Qpid Proton-J . Qpid Proton-J uses
java.util.logging . You can enable logging by creating a configuration file with the
contents shown in the next section. Or, set proton.trace.level=ALL and whichever
configuration options you want for the java.util.logging.Handler implementation. For
the implementation classes and their options, see Package java.util.logging in the Java
8 SDK documentation.

To trace the AMQP transport frames, set the PN_TRACE_FRM=1 environment variable.

Sample "logging.properties" file

The following configuration file logs TRACE level output from Proton-J to the proton-
trace.log file:

properties

handlers=java.util.logging.FileHandler
.level=OFF
proton.trace.level=ALL
java.util.logging.FileHandler.level=ALL
java.util.logging.FileHandler.pattern=proton-trace.log
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=[%1$tF %1$tr] %3$s %4$s: %5$s %n

Reduce logging
One way to decrease logging is to change the verbosity. Another way is to add filters
that exclude logs from logger names packages like com.azure.messaging.eventhubs or
com.azure.core.amqp . For examples, see the XML files in the Configuring Log4J 2 and

Configure logback sections.

When you submit a bug, the log messages from classes in the following packages are
interesting:

com.azure.core.amqp.implementation
 com.azure.core.amqp.implementation.handler

The exception is that you can ignore the onDelivery message in

ReceiveLinkHandler .
com.azure.messaging.eventhubs.implementation

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot Azure Event Hubs
producer
Article • 04/02/2025

This article provides solutions to common problems that you might encounter when you
use the EventHubsProducerClient and EventHubsProducerAsyncClient types. If you're
looking for solutions to other common problems that you might encounter when you
use Event Hubs, see Troubleshoot Azure Event Hubs.

Can't set multiple partition keys for events in

EventDataBatch
When the Event Hubs service publishes messages, it supports a single partition key for
each EventDataBatch . You should consider using the buffered producer client
EventHubBufferedProducerClient if you want that capability. Otherwise, you have to

manage your batches.

Setting partition key on EventData isn't set in

Kafka consumer
The partition key of the Event Hubs event is available in the Kafka record headers. The
protocol-specific key is x-opt-partition-key in the header.

By design, Event Hubs doesn't promote the Kafka message key to be the Event Hubs
partition key nor the reverse because with the same value, the Kafka client and the Event
Hubs client likely send the message to two different partitions. It might cause some
confusion if we set the value in the cross-protocol communication case. Exposing the
properties with a protocol specific key to the other protocol client should be good
enough.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot Azure Event Hubs event
processor
Article • 05/02/2025

This article provides solutions to common problems that you might encounter when you use
the EventProcessorClient type. If you're looking for solutions to other common problems that
you might encounter when you use Azure Event Hubs, see Troubleshoot Azure Event Hubs.

412 precondition failures when you use an event

processor
412 precondition errors occur when the client tries to take or renew ownership of a partition,
but the local version of the ownership record is outdated. This problem occurs when another
processor instance steals partition ownership. For more information, see the next section.

Partition ownership changes frequently

When the number of EventProcessorClient instances changes (that is, are added or removed),
the running instances try to load-balance partitions between themselves. For a few minutes
after the number of processors changes, partitions are expected to change owners. After it's
balanced, partition ownership should be stable and change infrequently. If partition ownership
is changing frequently when the number of processors is constant, it likely indicates a problem.
We recommended that you file a GitHub issue with logs and a repro.

Partition ownership is determined via the ownership records in the CheckpointStore . On every
load balancing interval, the EventProcessorClient will perform the following tasks:

1. Fetch the latest ownership records.

2. Check the records to see which records haven't updated their timestamp within the
partition ownership expiration interval. Only records matching this criteria are considered.
3. If there are any unowned partitions and the load is not balanced between instances of
EventProcessorClient , the event processor client will try to claim a partition.

4. Update the ownership record for the partitions it owns that have an active link to that
partition.

You can configure the load balancing and ownership expiration intervals when you create the
EventProcessorClient via the EventProcessorClientBuilder , as described in the following list:

The loadBalancingUpdateInterval(Duration) method indicates how often the load

balancing cycle runs.
 The partitionOwnershipExpirationInterval(Duration) method indicates the minimum
amount of time since the ownership record has been updated, before the processor
considers a partition unowned.

For example, if an ownership record was updated at 9:30am and

partitionOwnershipExpirationInterval is 2 mins. When a load balance cycle occurs and it

notices that the ownership record has not been updated in the last 2 min or by 9:32am, it will
consider the partition unowned.

If an error occurs in one of the partition consumers, it will close the corresponding consumer
but will not try to reclaim it until the next load balancing cycle.

"...current receiver '<RECEIVER_NAME>' with

epoch '0' is getting disconnected"
The entire error message looks similar to the following output:

Output

New receiver 'nil' with higher epoch of '0' is created hence current receiver
'nil' with epoch '0'
is getting disconnected. If you are recreating the receiver, make sure a higher
epoch is used.
TrackingId:&lt;GUID&gt;,
SystemTracker:&lt;NAMESPACE&gt;:eventhub:&lt;EVENT_HUB_NAME&gt;|&lt;CONSUMER_GROUP
&gt;,
Timestamp:2022-01-01T12:00:00}"}

This error is expected when load balancing occurs after EventProcessorClient instances are
added or removed. Load balancing is an ongoing process. When you use the
BlobCheckpointStore with your consumer, every ~30 seconds (by default), the consumer

checks to see which consumers have a claim for each partition, then runs some logic to
determine whether it needs to 'steal' a partition from another consumer. The service
mechanism used to assert exclusive ownership over a partition is known as the Epoch.

However, if no instances are being added or removed, there's an underlying issue that should
be addressed. For more information, see the Partition ownership changes frequently section
and Filing GitHub issues .

High CPU usage

High CPU usage is usually because an instance owns too many partitions. We recommend no
more than three partitions for every CPU core. It's better to start with 1.5 partitions for each
CPU core and then test by increasing the number of partitions owned.

Out of memory and choosing the heap size

The out of memory (OOM) problem can happen if the current max heap for the JVM is
insufficient to run the application. You may want to measure the application's heap
requirement. Then, based on the result, size the heap by setting the appropriate max heap
memory using the -Xmx JVM option.

You shouldn't specify -Xmx as a value larger than the memory available or limit set for the host
(the VM or container) - for example, the memory requested in the container's configuration.
You should allocate enough memory for the host to support the Java heap.

The following steps describe a typical way to measure the value for max Java Heap:

1. Run the application in an environment close to production, where the application sends,
receives, and processes events under the peak load expected in production.

2. Wait for the application to reach a steady state. At this stage, the application and JVM
would have loaded all domain objects, class types, static instances, object pools (TCP, DB
connection pools), etc.

Under the steady state, you see the stable sawtooth-shaped pattern for the heap
collection, as shown in the following screenshot:
 

3. After the application reaches the steady state, force a full garbage collection (GC) using
tools like JConsole. Observe the memory occupied after the full GC. You want to size the
heap such that only 30% is occupied after the full GC. You can use this value to set the
max heap size (using -Xmx ).

If you're on the container, then size the container to have an extra ~1 GB of memory for the
non-heap need for the JVM instance.

Processor client stops receiving

The processor client often continually runs in a host application for days on end. Sometimes, it
notices that EventProcessorClient isn't processing one or more partitions. Usually, there isn't
enough information to determine why the exception occurred. The EventProcessorClient
stopping is the symptom of an underlying cause (that is, the race condition) that occurred
while trying to recover from a transient error. For the information we require, see Filing GitHub
issues .

Duplicate EventData received when processor is

restarted
The EventProcessorClient and Event Hubs service guarantees an at-least-once delivery. You
can add metadata to discern duplicate events. For more information, see Does Azure Event
Hubs guarantee an at-least once delivery? on Stack Overflow. If you require only-once
delivery, you should consider Service Bus, which waits for an acknowledgment from the client.
For a comparison of the messaging services, see Choosing between Azure messaging services.

Low-level consumer client stops receiving

EventHubConsumerAsyncClient is a low-level consumer client provided by the Event Hubs library,

designed for advanced users who require greater control and flexibility over their Reactive
applications. This client offers a low-level interface, enabling users to manage backpressure,
threading, and recovery within the Reactor chain. Unlike EventProcessorClient ,
EventHubConsumerAsyncClient doesn't include automatic recovery mechanisms for all terminal

causes. Therefore, users must handle terminal events and select appropriate Reactor operators
to implement recovery strategies.

The EventHubConsumerAsyncClient::receiveFromPartition method emits a terminal error when

the connection encounters a non-retriable error or when a series of connection recovery
attempts fail consecutively, exhausting the maximum retry limit. Although the low-level
receiver attempts to recover from transient errors, users of the consumer client are expected to
handle terminal events. If continuous event reception is desired, the application should adjust
the Reactor chain to create a new consumer client on a terminal event.

Migrate from legacy to new client library

The migration guide includes steps on migrating from the legacy client and migrating legacy
checkpoints.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you use the
Azure SDK for Java client libraries, we recommended that you file an issue in the Azure SDK
for Java GitHub repository .
Troubleshoot Azure Event Hubs
performance
Article • 04/02/2025

This article provides solutions to common performance problems that you might
encounter when you use the Event Hubs library in the Azure SDK for Java. If you're
looking for solutions to other common problems that you might encounter when you
use Event Hubs, see Troubleshooting Azure Event Hubs.

Use processEvent or processEventBatch

When you use the processEvent callback, each EventData instance received calls your
code. This process works well with low or moderate traffic in the event hub.

If the event hub has high traffic and high throughput is expected, the aggregated cost
of continuously calling your callback hinders performance of EventProcessorClient . In
this case, you should use processEventBatch .

For each partition, your callback is invoked one at a time. High processing time in the
callback hinders performance because the EventProcessorClient doesn't continue to
push more events downstream nor request more EventData instances from the Event
Hubs service.

Costs of checkpointing
When you use Azure Blob Storage as the checkpoint store, there's a network cost to
checkpointing because it makes an HTTP request and waits for a response. This process
could take up to several seconds due to network latency, the performance of Azure Blob
Storage, resource location, and so on.

Checkpointing after every EventData instance is processed hinders performance due to

the cost of making these HTTP requests. You shouldn't checkpoint if your callback
processed no events, or you should checkpoint after processing some number of events.

Use LoadBalancingStrategy.BALANCED or
LoadBalancingStrategy.GREEDY
When you use LoadBalancingStrategy.BALANCED , the EventProcessorClient claims one
partition for every load balancing cycle. If there are 32 partitions in an event hub, it takes
32 load-balancing iterations to claim all the partitions. If users know a set number of
EventProcessorClient instances are running, they can use

LoadBalancingStrategy.GREEDY to claim their share of the partitions in one load-

balancing cycle.

For more information about each strategy, see LoadBalancingStrategy.java in the

azure-sdk-for-java repository .

Configure prefetchCount
The default prefetch value is 500. When the AMQP receive link is opened, it places 500
credits on the link. Assuming that each EventData instance is one link credit,
EventProcessorClient prefetches 500 EventData instances. When all the events are

consumed, the processor client adds 500 credits to the link to receive more messages.
This flow repeats while the EventProcessorClient still has ownership of a partition.

Configuring prefetchCount may have performance implications if the number is too low.
Each time the AMQP receive link places credits, the remote service sends an ACK. For
high throughput scenarios, the overhead of making thousands of client requests and
service ACKs may hinder performance.

Configuring prefetchCount may have performance implications if the number is too

high. When x credits are placed on the line, the Event Hubs service knows that it can
send at most x messages. When each EventData instance is received, it's placed in an in-
memory queue, waiting to be processed. A high number of EventData instances in the
queue can result in very high memory usage.

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No
Provide product feedback | Get help at Microsoft Q&A
Troubleshoot Azure Service Bus
Article • 02/12/2025

This article covers failure investigation techniques, concurrency, common errors for the
credential types in the Azure Service Bus Java client library, and mitigation steps to
resolve these errors.

Enable and configure logging

Azure SDK for Java offers a consistent logging story to help in troubleshooting
application errors and to help expedite their resolution. The logs produced capture the
flow of an application before reaching the terminal state to help locate the root issue.
For guidance on logging, see Configure logging in the Azure SDK for Java and
Troubleshooting overview.

In addition to enabling logging, setting the log level to VERBOSE or DEBUG provides
insights into the library's state. The following sections show sample log4j2 and logback
configurations to reduce the excessive messages when verbose logging is enabled.

Configure Log4J 2
Use the following steps to configure Log4J 2:

1. Add the dependencies in your pom.xml using ones from the logging sample
pom.xml , in the "Dependencies required for Log4j2" section.
2. Add log4j2.xml to your src/main/resources folder.

Configure logback
Use the following steps to configure logback:

1. Add the dependencies in your pom.xml using ones from the logging sample
pom.xml , in the "Dependencies required for logback" section.
2. Add logback.xml to your src/main/resources folder.

Enable AMQP transport logging

If enabling client logging isn't enough to diagnose your issues, you can enable logging
to a file in the underlying AMQP library, Qpid Proton-J . Qpid Proton-J uses
java.util.logging . You can enable logging by creating a configuration file with the
contents shown in the next section. Or, set proton.trace.level=ALL and whichever
configuration options you want for the java.util.logging.Handler implementation. For
the implementation classes and their options, see Package java.util.logging in the Java
8 SDK documentation.

To trace the AMQP transport frames, set the PN_TRACE_FRM=1 environment variable.

Sample logging.properties file

The following configuration file logs TRACE level output from Proton-J to the file
proton-trace.log:

properties

handlers=java.util.logging.FileHandler
.level=OFF
proton.trace.level=ALL
java.util.logging.FileHandler.level=ALL
java.util.logging.FileHandler.pattern=proton-trace.log
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=[%1$tF %1$tr] %3$s %4$s: %5$s %n

Reduce logging
One way to decrease logging is to change the verbosity. Another way is to add filters
that exclude logs from logger names packages like com.azure.messaging.servicebus or
com.azure.core.amqp . For examples, see the XML files in the Configure Log4J 2 and

Configure logback sections.

When you submit a bug, the log messages from classes in the following packages are
interesting:

com.azure.core.amqp.implementation
com.azure.core.amqp.implementation.handler

The exception is that you can ignore the onDelivery message in

ReceiveLinkHandler .

com.azure.messaging.servicebus.implementation

Concurrency in ServiceBusProcessorClient
ServiceBusProcessorClient enables the application to configure how many calls to the

message handler should happen concurrently. This configuration makes it possible to

process multiple messages in parallel. For a ServiceBusProcessorClient consuming
messages from a non-session entity, the application can configure the desired
concurrency using the maxConcurrentCalls API. For a session enabled entity, the desired
concurrency is maxConcurrentSessions times maxConcurrentCalls .

If the application observes fewer concurrent calls to the message handler than the
configured concurrency, it might be because the thread pool is not sized appropriately.

ServiceBusProcessorClient uses daemon threads from the Reactor global

boundedElastic thread pool to invoke the message handler. The maximum number of
concurrent threads in this pool is limited by a cap. By default, this cap is ten times the
number of available CPU cores. For the ServiceBusProcessorClient to effectively
support the application's desired concurrency ( maxConcurrentCalls or
maxConcurrentSessions times maxConcurrentCalls ), you must have a boundedElastic

pool cap value that's higher than the desired concurrency. You can override the default
cap by setting the system property reactor.schedulers.defaultBoundedElasticSize .

You should tune the thread pool and CPU allocation on a case-by-case basis. However,
when you override the pool cap, as a starting point, limit the concurrent threads to
approximately 20-30 per CPU core. We recommend that you cap the desired
concurrency per ServiceBusProcessorClient instance to approximately 20-30. Profile
and measure your specific use case and tune the concurrency aspects accordingly. For
high load scenarios, consider running multiple ServiceBusProcessorClient instances
where each instance is built from a new ServiceBusClientBuilder instance. Also,
consider running each ServiceBusProcessorClient in a dedicated host - such as a
container or VM - so that downtime in one host doesn't impact the overall message
processing.

Keep in mind that setting a high value for the pool cap on a host with few CPU cores
would have adverse effects. Some signs of low CPU resources or a pool with too many
threads on fewer CPUs are: frequent timeouts, lock lost, deadlock, or lower throughput.
If you're running the Java application on a container, then we recommend using two or
more vCPU cores. We don't recommend selecting anything less than 1 vCPU core when
running Java application on containerized environments. For in-depth recommendations
on resourcing, see Containerize your Java applications.

Connection sharing bottleneck

All the clients created from a shared ServiceBusClientBuilder instance share the same
connection to the Service Bus namespace.
Using a shared connection enables multiplexing operations among clients on one
connection, but sharing can also become a bottleneck if there are many clients, or the
clients together generate high load. Each connection has an I/O thread associated with
it. When sharing connection, the clients put their work in this shared I/O thread's work-
queue and the progress of each client depends on the timely completion of its work in
the queue. The I/O thread handles the enqueued work serially. That is, if the I/O thread
work-queue of a shared connection ends up with a lot of pending work to deal with,
then the symptoms are similar to those of low CPU. This condition is described in the
previous section on concurrency - for example, clients stalling, timeout, lost lock, or
slowdown in recovery path.

Service Bus SDK uses the reactor-executor-* naming pattern for the connection I/O
thread. When the application experiences the shared connection bottleneck, then it
might be reflected in the I/O thread's CPU usage. Also, in the heap dump or in live
memory, the object ReactorDispatcher$workQueue is the work-queue of the I/O thread. A
long work-queue in the memory snapshot during the bottleneck period might indicate
that the shared I/O thread is overloaded with pending works.

Therefore, if the application load to a Service Bus endpoint is reasonably high in terms
of overall number of sent-received messages or payload size, you should use a separate
builder instance for each client that you build. For example, for each entity - queue or
topic - you can create a new ServiceBusClientBuilder and build a client from it. In case
of extremely high load to a specific entity, you might want to either create multiple
client instances for that entity or run clients in multiple hosts - for example, containers
or VMs - to load balance.

Clients halt when using Application Gateway

custom endpoint
The custom endpoint address refers to an application-provided HTTPS endpoint address
resolvable to Service Bus or configured to route traffic to Service Bus. Azure Application
Gateway makes it easy to create an HTTPS front-end that forwards traffic to Service Bus.
You can configure Service Bus SDK for an application to use an Application Gateway
front-end IP address as the custom endpoint to connect to Service Bus.

Application Gateway offers several security policies supporting different TLS protocol
versions. There are predefined policies enforcing TLSv1.2 as the minimum version, there
also exist old policies with TLSv1.0 as the minimum version. The HTTPS front-end will
have a TLS policy applied.
Right now, the Service Bus SDK doesn't recognize certain remote TCP terminations by
the Application Gateway front end, which uses TLSv1.0 as the minimum version. For
instance, if the front end sends TCP FIN, ACK packets to close the connection when its
properties are updated, the SDK can't detect it, so it won't reconnect, and clients can't
send or receive messages anymore. Such a halt only happens when using TLSv1.0 as the
minimum version. To mitigate, use a security policy with TLSv1.2 or higher as the
minimum version for the Application Gateway front-end.

The support for TLSv1.0 and 1.1 across all Azure Services is already announced to end
by 31 October 2024, so transitioning to TLSv1.2 is strongly recommended.

Message or session lock is lost

A Service Bus queue or topic subscription has a lock duration set at the resource level.
When the receiver client pulls a message from the resource, the Service Bus broker
applies an initial lock to the message. The initial lock lasts for the lock duration set at the
resource level. If the message lock isn't renewed before it expires, then the Service Bus
broker releases the message to make it available for other receivers. If the application
tries to complete or abandon a message after the lock expiration, the API call fails with
the error com.azure.messaging.servicebus.ServiceBusException: The lock supplied is
invalid. Either the lock expired, or the message has already been removed from the
queue .

The Service Bus client supports running a background lock renew task that renews the
message lock continuously each time before it expires. By default, the lock renew task
runs for 5 minutes. You can adjust the lock renew duration by using
ServiceBusReceiverClientBuilder.maxAutoLockRenewDuration(Duration) . If you pass the
Duration.ZERO value, the lock renew task is disabled.

The following lists describes some of the usage patterns or host environments that can
lead to the lock lost error:

The lock renew task is disabled and the application's message processing time
exceeds the lock duration set at the resource level.

The application's message processing time exceeds the configured lock renew task
duration. Note that, if the lock renew duration is not set explicitly, it defaults to 5
minutes.

The application has turned on the Prefetch feature by setting the prefetch value to
a positive integer using
ServiceBusReceiverClientBuilder.prefetchCount(prefetch) . When the Prefetch
 feature is enabled, the client will retrieve the number of messages equal to the
prefetch from the Service Bus entity - queue or topic - and store them in the in-
memory prefetch buffer. The messages stay in the prefetch buffer until they're
received into the application. The client doesn't extend the lock of the messages
while they're in the prefetch buffer. If the application processing takes so long that
message locks expire while staying in the prefetch buffer, then the application
might acquire the messages with an expired lock. For more information, see Why is
Prefetch not the default option?

The host environment has occasional network problems - for example, transient
network failure or outage - that prevent the lock renew task from renewing the
lock on time.

The host environment lacks enough CPUs or has shortages of CPU cycles
intermittently that delays the lock renew task from running on time.

The host system time isn't accurate - for example, the clock is skewed - delaying
the lock renew task and keeping it from running on time.

The connection I/O thread is overloaded, impacting its ability to execute lock
renew network calls on time. The following two scenarios can cause this issue:
The application is running too many receiver clients sharing the same
connection. For more information, see the Connection sharing bottleneck
section.
The application has configured ServiceBusReceiverClient.receiveMessages or
ServiceBusProcessorClient to have a large maxMessages or maxConcurrentCalls

values. For more information, see the Concurrency in ServiceBusProcessorClient

section.

The number of lock renew tasks in the client is equal to the maxMessages or
maxConcurrentCalls parameter values set for ServiceBusProcessorClient or

ServiceBusReceiverClient.receiveMessages . A high number of lock renew tasks making

multiple network calls can also have an adverse effect in Service Bus namespace
throttling.

If the host is not sufficiently resourced, the lock can still be lost even if there are only a
few lock renew tasks running. If you're running the Java application on a container, then
we recommend using two or more vCPU cores. We don't recommend selecting anything
less than 1 vCPU core when running Java applications on containerized environments.
For in-depth recommendations on resourcing, see Containerize your Java applications.

The same remarks about locks are also relevant for a Service Bus queue or a topic
subscription that has session enabled. When the receiver client connects to a session in
the resource, the broker applies an initial lock to the session. To maintain the lock on the
session, the lock renew task in the client has to keep renewing the session lock before it
expires. For a session enabled resource, the underlying partitions sometimes move to
achieve load balancing across Service Bus nodes - for example, when new nodes are
added to share the load. When that happens, session locks can be lost. If the application
tries to complete or abandon a message after the session lock is lost, the API call fails
with the error com.azure.messaging.servicebus.ServiceBusException: The session lock
was lost. Request a new session receiver .

Next steps
If the troubleshooting guidance in this article doesn't help to resolve issues when you
use the Azure SDK for Java client libraries, we recommended that you file an issue in
the Azure SDK for Java GitHub repository .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot dependency version
conflicts
Article • 04/02/2025

This article describes dependency version conflicts and how to troubleshoot them.

Azure client libraries for Java depend on popular third-party libraries such as the
following ones:

Jackson
Netty
Reactor
SLF4J

Many Java applications and frameworks use these libraries directly or transitively, which
leads to version conflicts . Dependency managers such as Maven and Gradle
resolve all dependencies so that there's only a single version of each dependency on the
classpath. However, it's not guaranteed that the resolved dependency version is
compatible with all consumers of that dependency in your application. For more
information, see Introduction to the Dependency Mechanism in the Maven
documentation and Understanding dependency resolution in the Gradle
documentation.

The API incompatibility of direct dependencies results in compilation errors. Diamond

dependency incompatibility usually results in runtime failures such as
NoClassDefFoundError , NoSuchMethodError , or other LinkageError . Not all
libraries strictly follow semantic versioning , and breaking changes sometimes happen
within the same major version.

Diagnose version mismatch issues

The following sections describe methods on how to diagnose version mismatch issues.

Use the Azure SDK for Java build tool

The Azure SDK for Java build tool, introduced in Get started with Azure SDK and Apache
Maven, helps to identify commonly encountered issues. We recommend that you add
this build tool to your project and run it by adding the azure:run Maven target to your
regular build process. With the appropriate configuration, you can identify and resolve
dependency conflicts more proactively, before they become issues at runtime.
View a dependency tree
Run mvn dependency:tree or gradle dependencies --scan to show the full dependency
tree for your application, with version numbers. mvn dependency:tree -Dverbose gives
more information, but may be misleading. For more information, see Apache Maven
Dependency Tree in the Maven documentation. For each library that you suspect has
a version conflict, note its version number and determine which components depend on
it.

Dependency resolution in development and production environments may work

differently. Apache Spark , Apache Flink , Databricks , and IDE plugins need extra
configuration for custom dependencies. They can also bring their own versions of Azure
Client libraries or common components. For more information, see the following articles:

Bundling Your Application’s Dependencies for Apache Spark

Project Configuration for Apache Flink
How to correctly update a Maven library in Databricks for Databricks

For more information on conflict resolution in such environments, see the Create a fat
JAR section later in this article.

Configure Azure Functions

The internal dependency version on Azure Functions (running Java 8 only) takes
precedence over a user-provided one. This dependency causes version conflicts,
especially with Jackson, Netty, and Reactor.

To solve this problem, set the FUNCTIONS_WORKER_JAVA_LOAD_APP_LIBS environment

variable to true or 1 . Be sure to update the Azure Function Tools (v2 or v3) to the latest
version.

７ Note

This configuration applies to Azure Functions running Java 8 only, Functions

running Java 11 don't need special configuration.

Configure Apache Spark

The Azure SDK for Java supports multiple versions of Jackson, but issues can sometimes
arise depending on your build tooling and its dependency resolution ordering. A good
example of this problem is with Apache Spark, version 3.0.0 and later, which depends on
Jackson 2.10. While it's compatible with the Azure SDK for Java, developers often
discover that a more recent version of Jackson is used instead, which results in
incompatibilities. To mitigate this problem, you should pin a specific version of Jackson
(one that is compatible with Spark). For more information, see the Support for multiple
Jackson versions section in this article.

If you use earlier versions of Spark, or if another library you use requires an even earlier
version of Jackson that the Azure SDK for Java doesn't support, continue reading this
article for possible mitigation steps.

Detect Jackson runtime version

In Azure Core 1.21.0, we added runtime detection and better diagnostics of the Jackson
runtime version.

If you see LinkageError (or any of its subclasses) related to the Jackson API, check the
message of the exception for runtime version information. For example:
com.azure.core.implementation.jackson.JacksonVersionMismatchError:
com/fasterxml/jackson/databind/cfg/MapperBuilder Package versions: jackson-

annotations=2.9.0, jackson-core=2.9.0, jackson-databind=2.9.0, jackson-dataformat-

xml=2.9.0, jackson-datatype-jsr310=2.9.0, azure-core=1.19.0-beta.2

Look for warning and error logs from JacksonVersion . For more information, see
Configure logging in the Azure SDK for Java. For example: [main] ERROR
com.azure.core.implementation.jackson.JacksonVersion - Version '2.9.0' of package

'jackson-core' is not supported (too old), please upgrade.

７ Note

Check that all of the Jackson packages have the same version.

For the list of packages used by Azure SDK and the supported Jackson versions, see the
Support for multiple Jackson versions section.

Mitigate version mismatch issues

The following sections describe how to mitigate version mismatch issues.

Use Azure SDK BOM

Use the latest stable Azure SDK BOM and don't specify Azure SDK and dependency
versions in your POM file. When applicable, use the Azure Spring Boot BOM .

The dependencies listed in the Azure SDK BOM are tested rigorously to avoid
dependency conflicts.

Avoid unnecessary dependencies

Remove dependencies if you can. Sometimes, an application has dependencies on
multiple libraries that provide essentially the same functionality. Such unnecessary
dependencies expose applications to security vulnerabilities, version conflicts, and
support and maintenance costs.

Update dependency versions

If switching to the latest Azure SDK BOM doesn't help, identify the libraries causing
conflicts and the components that use them. (For more information, see the View a
dependency tree section earlier in this article.) Try updating to a newer version, which
protects against security vulnerabilities, and often brings new features, performance
improvements, and bug fixes.

Avoid downgrading the Azure SDK version because it may expose your application to
known vulnerabilities and issues.

Shade libraries
Sometimes there's no combination of libraries that work together, and shading comes
as the last resort.

７ Note

Shading has significant drawbacks: it increases package size and number of classes
on the classpath, it makes code navigation and debugging hard, doesn't relocate
JNI code, breaks reflection, and may violate code licenses among other things. It
should be used only after other options are exhausted.

Shading enables you to include dependencies within a JAR at build time, then rename
packages and update application code to use the code in the shaded location. Diamond
dependency conflict is no longer an issue because there are two different copies of a
dependency. You may shade a library that has a conflicting transitive dependency or a
direct application dependency, as described in the following list:
 Transitive dependency conflict: For example, third-party library A requires Jackson
2.9, which Azure SDKs don't support, and it's not possible to update A . Create a
new module, which includes A and shades (relocates) Jackson 2.9 and, optionally,
other dependencies of A .
Application dependency conflict: Your application uses Jackson 2.9 directly. While
you're working on updating your code, you can shade and relocate Jackson 2.9
into a new module with relocated Jackson classes instead.

７ Note

Creating fat JAR with relocated Jackson classes doesn't resolve a version conflict in
these examples - it only forces a single shaded version of Jackson.

Create a fat JAR

Environments like Databricks or Apache Spark have custom dependency management
and provide common libraries like Jackson. To avoid conflict with provided libraries, you
may want to build a fat JAR that contains all the dependencies. For more information,
see Apache Maven Shade Plugin . In many cases, relocating Jackson classes
( com.fasterxml.jackson ) mitigates the issue. Sometimes such environments also bring
their own version of Azure SDKs, so you might be compelled to relocate com.azure
namespace to work around version conflicts.

Understand compatible dependency versions

For information about azure-core -specific dependencies and their versions, see azure-
core at the Maven Central Repository. The following table shows some general
considerations:

ﾉ Expand table

Dependency Supported versions

Jackson 2.10.0 and newer minor versions are compatible. For more information, see
the Support for multiple Jackson versions section.

SLF4J 1.7.*

netty-tcnative- 2.0.*
boringssl-static
 Dependency Supported versions

netty-common 4.1.*

reactor-core 3.X.* - Major and minor version numbers must exactly match the ones your
azure-core version depends on. For more information, see the Project
Reactor policy on deprecations .

Support for multiple Jackson versions

The Azure SDK for Java supports working with a range of Jackson versions. The lowest-
supported version is Jackson 2.10.0. The Azure SDK for Java client libraries adjust their
configuration and Jackson usage depending on the version that is detected at runtime.
This adjustment enables greater compatibility with older versions of the Spring
framework, Apache Spark, and other common environments. Applications can
downgrade Jackson versions (to 2.10.0 or higher) without breaking Azure SDK for Java
client libraries.

７ Note

Using old versions of Jackson may expose applications to known vulnerabilities and
issues. For more information, see the list of known vulnerabilities for Jackson
libraries .

When pinning a specific version of Jackson, make sure to do it for all modules used by
Azure SDK, which are shown in the following list:

jackson-annotations

jackson-core
jackson-databind

jackson-dataformat-xml
jackson-datatype-jsr310

Migration from Jackson to azure-json

Azure client libraries for Java are in the process of migration to azure-json , which
doesn't depend on any 3rd party components, and offers shared primitives,
abstractions, and helpers for JSON.

Environments like Apache Spark, Apache Flink, and Databricks might bring older
versions of azure-core that don't yet depend on azure-json . As a result, when using
newer versions of Azure libraries in such environments, you might get errors similar to
java.lang.NoClassDefFoundError: com/azure/json/JsonSerializable . You can mitigate

this error by adding an explicit dependency on azure-json .

Next steps
Now that you're familiar with dependency version conflicts and how to troubleshoot
them, see Dependency Management for Java for information on the best way to
prevent them.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Troubleshoot networking issues
Article • 04/02/2025

This article describes a few tools that can diagnose networking issues of various
complexities. These issues include scenarios that range from troubleshooting an
unexpected response value from a service, to root-causing a connection-closed
exception.

For client-side troubleshooting, the Azure client libraries for Java offer a consistent and
robust logging story, as described in Configure logging in the Azure SDK for Java.
However, the client libraries make network calls over various protocols, which may lead
to troubleshooting scenarios that extend outside of the troubleshooting scope
provided. When these problems occur, the solution is to use the external tooling
described in this article to diagnose networking issues.

Fiddler
Fiddler is an HTTP debugging proxy that allows for requests and responses passed
through it to be logged as-is. The raw requests and responses that you capture can help
you troubleshoot scenarios where the service gets an unexpected request, or the client
receives an unexpected response. To use Fiddler, you need to configure the client library
with an HTTP proxy. If you use HTTPS, you need extra configuration to inspect the
decrypted request and response bodies.

Add an HTTP proxy

To add an HTTP proxy, follow the guidance in Configure proxies in the Azure SDK for
Java. Be sure to use the default Fiddler address of localhost on port 8888.

Enable HTTPS decryption

By default, Fiddler can capture only HTTP traffic. If your application uses HTTPS, you
must take extra steps to trust Fiddler's certificate to allow it to capture HTTPS traffic. For
more information, see HTTPS Menu in the Fiddler documentation.

The following steps show you how to use the Java Runtime Environment (JRE) to trust
the certificate. If the certificate isn't trusted, an HTTPS request through Fiddler may fail
with security warnings.
 Windows

1. Export Fiddler's certificate. The certificate is typically exported to the desktop.

2. Find the JRE's keytool (usually in jre\bin).

3. Find the JRE's cacert (usually in jre\lib\security).

4. Open a PowerShell window in administrator mode and use the following

command to import the certificate:

PowerShell

keytool.exe -import -trustcacerts -file <location-of-Fiddler-

certificate> -keystore <location-of-cacert> -alias Fiddler

For example, the following command uses some common values:

PowerShell

keytool.exe -import -trustcacerts -file

"C:\Users\username\Desktop\FiddlerRootCertificate.crt" -keystore
"C:\Program Files\AdoptOpenJDK\jdk-8.0.275.1-
hotspot\jre\lib\security\cacerts" -alias Fiddler

5. Enter a password. If you haven't set a password before, the default is

changeit . For more information, see Working with Certificates and SSL in
the Oracle documentation.

6. Trust the certificate.

Wireshark
Wireshark is a network protocol analyzer that can capture network traffic without
needing changes to application code. Wireshark is highly configurable and can capture
broad to specific, low-level network traffic. This capability is useful for troubleshooting
scenarios such as a remote host closing a connection or having connections closed
during an operation. The Wireshark GUI displays captures using a color scheme that
identifies unique capture cases, such as a TCP retransmission, RST, and so on. You can
also filter captures either at capture time or during analysis.
Configure a capture filter
Capture filters reduce the number of network calls that are captured for analysis.
Without capture filters, Wireshark captures all traffic that goes through a network
interface. This behavior can produce massive amounts of data where most of it may be
noise to the investigation. Using a capture filter helps preemptively scope the network
traffic being captured to help target an investigation. For more information, see
Capturing Live Network Data in the Wireshark documentation.

The following example adds a capture filter to capture network traffic sent to or received
from a specific host.

In Wireshark, navigate to Capture > Capture Filters... and add a new filter with the value
host <host-IP-or-hostname> . This filter captures traffic only to and from that host. If the

application communicates to multiple hosts, you can add multiple capture filters, or you
can add the host IP/hostname with the 'OR' operator to provide looser capture filtering.

Capture to disk
You might need to run an application for a long time to reproduce an unexpected
networking exception, and to see the traffic that leads up to it. Additionally, it may not
be possible to maintain all captures in memory. Fortunately, Wireshark can log captures
to disk so that they're available for post-processing. This approach avoids the risk of
running out of memory while you reproduce an issue. For more information, see File
Input, Output, And Printing in the Wireshark documentation.

The following example sets up Wireshark to persist captures to disk with multiple files,
where the files split on either 100k captures or 50 MB size.

In Wireshark, navigate to Capture > Options and find the Output tab, then enter a file
name to use. This configuration causes Wireshark to persist captures to a single file.

To enable capture to multiple files, select Create a new file automatically and then
select after 100000 packets and after 50 megabytes. This configuration has Wireshark
create a new file when one of the predicates is matched. Each new file uses the same
base name as the file name entered and appends a unique identifier.

If you want to limit the number of files that Wireshark can create, select Use a ring
buffer with X files. This option limits Wireshark to logging with only the specified
number of files. When that number of files is reached, Wireshark begins overwriting the
files, starting with the oldest.
Filter captures
Sometimes you can't tightly scope the traffic that Wireshark captures - for example, if
your application communicates with multiple hosts using various protocols. In this
scenario, generally with using persistent capture outlined previously, it's easier to run
analysis after network capturing. Wireshark supports filter-like syntax for analyzing
captures. For more information, see Working With Captured Packets in the Wireshark
documentation.

The following example loads a persisted capture file and filters on ip.src_host==<IP> .

In Wireshark, navigate to File > Open and load a persisted capture from the file location
used previously. After the file has loaded underneath the menu bar, a filter input
appears. In the filter input, enter ip.src_host==<IP> . This filter limits the capture view so
that it shows only captures where the source was from the host with the IP <IP> .

Next steps
This article covered using various tools to diagnose networking issues when working
with the Azure SDK for Java. Now that you're familiar with the high-level usage
scenarios, you can begin exploring the SDK itself. For more information on the APIs
available, see the Azure SDK for Java libraries.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Azure management libraries for Java -
Virtual machine samples
06/02/2025

The following table links to Java source you can use to create and configure Azure virtual
machines.

ﾉ Expand table

Sample Description

Create a virtual machine from a Create a custom virtual machine image and use it to create new virtual
custom image machines.

Create a virtual machine using Create snapshot from the virtual machine's OS and data disks, create
specialized VHD from a managed disks from the snapshots, and then create a virtual machine
snapshot by attaching the managed disks.

Create virtual machines in Create virtual machines in the same region on the same virtual network
parallel in the same network with two subnets in parallel.
Azure management libraries for Java - Web
app samples
06/02/2025

The following table links to Java source you can use to create and configure web apps.

ﾉ Expand table

Sample Description

Create an app

Create a web app and deploy from Deploy web apps from local Git, FTP, and continuous integration
FTP or GitHub from GitHub.

Create a web app and manage Create a web app and deploy to staging slots, and then swap
deployment slots deployments between slots.

Configure an app

Create a web app and configure a Create a web app with a custom domain and self-signed SSL
custom domain certificate.

Scale an app

Scale a web app with high Scale a web app in three different geographical regions and make
availability across multiple regions them available through a single endpoint using Azure Traffic
Manager.

Connect an app to resources

Connect a web app to a storage Create an Azure storage account and add the storage account
account connection string to the app settings.

Connect a web app to a SQL Create a web app and SQL database, and then add the SQL
database database connection string to the app settings.
Azure management libraries for Java - SQL
Database samples
06/02/2025

The following table links to Java source you can use to manage SQL Database.

ﾉ Expand table

Sample Description

Connect and query data from Configure a sample database, then run select, insert, update, and delete
Azure SQL Database using commands.
JDBC

Create and manage SQL Create SQL databases, set performance levels, and configure firewalls.
databases

Manage SQL databases Create a master SQL database and read-only databases from the master
across multiple regions in multiple regions. Connect VMs to their nearest SQL database instance
with a virtual network and firewall rules.
Java source samples for Microsoft Entra ID
06/02/2025

The following table links to Java source you can use to access and work with Microsoft Entra ID
in your apps.

ﾉ Expand table

Sample Description

Integrating Microsoft Entra ID into a Java Set up OAuth2 authentication in a Java web app.
web application

Integrating Microsoft Entra ID into a Java Obtain a JWT access token through OAuth 2.0, then use the
command line using username and access token to authenticate with a Microsoft Entra
password protected web API.

Manage users, groups, and roles with the Manage users, groups, roles, and service principals with the
Graph API Graph API using the management API.

Manage service principals Create a service principal for an application, assign it a role,
and use the service principal to access resources in the
subscription
Java samples for Azure Container Service
06/02/2025

The following table links to Java source you can use to create and configure applications
running in Azure Container Service.

ﾉ Expand table

Sample Description

Manage Azure Container Registries Create a new Azure Container registry and add an new
image.

Manage Azure Container Service Create an Azure Container Service with Kubernetes
orchestration.

Deploy an image from Azure Container Deploy a Docker image running Tomcat to a new web
Registry into a new Linux Web App app running in Azure App Service for Linux.
Azure SDK for Java libraries
05/21/2025

The Azure SDK for Java is composed of many libraries - one for each Azure service.
Additionally, there are libraries designed to integrate with open-source projects, such as
Spring, to provide Azure-specific support. All Azure SDK for Java libraries are designed to work
together and provide a cohesive developer experience, as described in Use the Azure SDK for
Java. The SDK achieves this cohesion through a common set of concepts, including HTTP
pipelines, identity and authentication, and logging.

The following tables show all libraries that exist in the Azure SDK for Java. These tables provide
links to all relevant repositories and documentation. To keep up to date with the Azure SDKs,
consider following the @AzureSDK Twitter account and the Azure SDK blog .

Libraries using azure-core

All libraries

Libraries using azure-core

ﾉ Expand table

Name Package Docs Source

JDBC Authentication Plugin for MySQL Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

JDBC Authentication Plugin for PostgreSQL Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Token-as-password Authentication Core Library Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Token-as-password Authentication Extensions Maven 1.2.2 docs GitHub 1.2.2

AI Agents Persistent Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

AI Projects Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Anomaly Detector Maven 3.0.0- docs GitHub 3.0.0-

beta.5 beta.5

App Configuration Maven 1.8.0 docs GitHub 1.8.0

Name Package Docs Source

Attestation Maven 1.1.32 docs GitHub 1.1.32

Azure AI Inference Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

Azure AI Search Maven 11.7.6 docs GitHub 11.7.6

Maven 11.8.0- GitHub 11.8.0-
beta.7 beta.7

Azure Blob Storage Checkpoint Store Maven 1.20.7 docs GitHub 1.20.7
Maven 1.21.0- GitHub 1.21.0-
beta.1 beta.1

Azure Maps Elevation Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Azure Maps Geolocation Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Azure Maps TimeZone Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Azure Maps Traffic Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Azure Maps Weather Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Azure Redis Checkpoint Store Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Azure Remote Rendering Maven 1.1.37 docs GitHub 1.1.37

azure-core-http-jdk-httpclient Maven 1.0.3 docs GitHub 1.0.3

azure-core-http-vertx Maven 1.0.3 docs GitHub 1.0.3

azure-core-metrics-opentelemetry Maven 1.0.0- docs GitHub 1.0.0-

beta.29 beta.29

azure-json Maven 1.5.0 docs GitHub 1.5.0

azure-sdk-archetype Maven 1.0.0 GitHub 1.0.0

azure-sdk-build-tool Maven 1.0.0 docs GitHub 1.0.0

azure-xml Maven 1.2.0 docs GitHub 1.2.0

Calling Server Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4
Name Package Docs Source

CloudNative CloudEvents with Event Grid Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Communication Call Automation Maven 1.4.0 docs GitHub 1.4.0

Communication Chat Maven 1.5.9 docs GitHub 1.5.9

Communication Common Maven 1.3.11 docs GitHub 1.3.11

Maven 2.0.0- GitHub 2.0.0-
beta.1 beta.1

Communication Email Maven 1.0.21 docs GitHub 1.0.21

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1

Communication Identity Maven 1.6.4 docs GitHub 1.6.4

Communication JobRouter Maven 1.1.12 docs GitHub 1.1.12

Communication Messages Maven 1.1.3 docs GitHub 1.1.3

Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Communication Network Traversal Maven 1.1.0 docs GitHub 1.1.0

Communication Phone Numbers Maven 1.2.2 docs GitHub 1.2.2

Maven 1.3.0- GitHub 1.3.0-
beta.1 beta.1

Communication Rooms Maven 1.2.0 docs GitHub 1.2.0

Communication Sms Maven 1.1.32 docs GitHub 1.1.32

Compute Batch Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4

Confidential Ledger Maven 1.0.28 docs GitHub 1.0.28

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1

Container Registry Maven 1.2.16 docs GitHub 1.2.16

Content Safety Maven 1.0.11 docs GitHub 1.0.11

Core - Client - AMQP Maven 2.9.16 docs GitHub 2.9.16

Core - Client - Core Maven 1.55.3 docs GitHub 1.55.3

Core - Client - Core Experimental Maven 1.0.0- docs GitHub 1.0.0-

beta.60 beta.60
Name Package Docs Source

Core - Client - Core Serializer Apache Avro Maven 1.0.0- docs GitHub 1.0.0-
beta.56 beta.56

Core - Client - Core Serializer Apache Jackson Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Core - Client - Core Serializer GSON JSON Maven 1.3.8 docs GitHub 1.3.8

Core - Client - Core Serializer Jackson JSON Maven 1.5.8 docs GitHub 1.5.8

Core - Client - HTTP Netty Maven 1.15.11 docs GitHub 1.15.11

Core - Client - HTTP OkHttp Maven 1.12.10 docs GitHub 1.12.10

Core - Client - Test Maven 1.26.2 docs GitHub 1.26.2

Maven 1.27.0- GitHub 1.27.0-
beta.8 beta.8

Core - Plugin - Tracing OpenTelemetry Plugin Maven 1.0.0- docs GitHub 1.0.0-
beta.56 beta.56

Cosmos DB Maven 4.71.0 docs GitHub 4.71.0

Cosmos Kafka Connect Maven 2.3.1 GitHub 2.3.1

Cosmos Spark 3.4 Maven 4.37.2 GitHub 4.37.2

Cosmos Spark 3.5 Maven 4.37.2 GitHub 4.37.2

Cosmos Test Maven 1.0.0- docs GitHub 1.0.0-

beta.12 beta.12

Defender EASM Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Dev Center Maven 1.0.8 docs GitHub 1.0.8

Device Update Maven 1.0.26 docs GitHub 1.0.26

Digital Twins Maven 1.4.2 docs GitHub 1.4.2

Document Intelligence Maven 1.0.1 docs GitHub 1.0.1

Document Translation Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Document Translation Maven 1.0.1 docs GitHub 1.0.1

Event Grid Maven 4.30.0 docs GitHub 4.30.0

Event Grid Namespaces Maven 1.1.3 docs GitHub 1.1.3

Name Package Docs Source

Event Hubs Maven 5.20.3 docs GitHub 5.20.3

Maven 5.21.0- GitHub 5.21.0-
beta.1 beta.1

Face Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

FarmBeats Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Form Recognizer Maven 4.1.13 docs GitHub 4.1.13

Health Deidentification Maven 1.0.0 docs GitHub 1.0.0

Health Insights Cancer Profiling Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Health Insights Clinical Matching Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Health Insights Radiology Insights Maven 1.1.0 docs GitHub 1.1.0

Identity Maven 1.16.1 docs GitHub 1.16.1

Identity Broker Maven 1.1.14 docs GitHub 1.1.14

Image Analysis Maven 1.0.1 docs GitHub 1.0.1

Key Vault - Administration Maven 4.6.4 docs GitHub 4.6.4

Maven 4.7.0- GitHub 4.7.0-
beta.1 beta.1

Key Vault - Certificates Maven 4.7.4 docs GitHub 4.7.4

Maven 4.8.0- GitHub 4.8.0-
beta.1 beta.1

Key Vault - Keys Maven 4.9.4 docs GitHub 4.9.4

Maven 4.10.0- GitHub 4.10.0-
beta.1 beta.1

Key Vault - Secrets Maven 4.9.4 docs GitHub 4.9.4

Maven 4.10.0- GitHub 4.10.0-
beta.1 beta.1

Load Testing Maven 1.0.22 docs GitHub 1.0.22

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1

Maps Render Maven 2.0.0- docs GitHub 2.0.0-

beta.2 beta.2
Name Package Docs Source

Maps Route Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Maps Search Maven 2.0.0- docs GitHub 2.0.0-

beta.2 beta.2

Metrics Advisor Maven 1.2.6 docs GitHub 1.2.6

Mixed Reality Authentication Maven 1.2.32 docs GitHub 1.2.32

Models Repository Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Monitor Ingestion Maven 1.2.9 docs GitHub 1.2.9

Monitor Query Maven 1.5.7 docs GitHub 1.5.7

OpenAI Maven 1.0.0- docs GitHub 1.0.0-

beta.16 beta.16

OpenAI Assistants Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

OpenTelemetry AutoConfigure Maven 1.2.0 docs GitHub 1.2.0

OpenTelemetry Exporter Maven 1.0.0- docs GitHub 1.0.0-

beta.32 beta.32

Personalizer Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Purview Account Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Purview Administration Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Purview Catalog Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4

Purview Data Map Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Purview Scanning Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Purview Sharing Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Purview Workflow Maven 1.0.0- docs GitHub 1.0.0-

Name Package Docs Source

beta.2 beta.2

Quantum Jobs Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Schema Registry Maven 1.5.4 docs GitHub 1.5.4

Schema Registry - Avro Maven 1.1.25 docs GitHub 1.1.25

Maven 1.2.0- GitHub 1.2.0-
beta.2 beta.2

Schema Registry - Avro Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

Schema Registry - JSON Maven 1.0.1 docs GitHub 1.0.1

Service Bus Maven 7.17.11 docs GitHub 7.17.11

Maven 7.18.0- GitHub 7.18.0-
beta.1 beta.1

Storage - Blobs Maven 12.30.0 docs GitHub 12.30.0

Maven 12.31.0- GitHub 12.31.0-
beta.1 beta.1

Storage - Blobs Batch Maven 12.26.0 docs GitHub 12.26.0

Maven 12.27.0- GitHub 12.27.0-
beta.1 beta.1

Storage - Blobs Changefeed Maven 12.0.0- docs GitHub 12.0.0-

beta.30 beta.30

Storage - Blobs Cryptography Maven 12.29.0 docs GitHub 12.29.0

Maven 12.30.0- GitHub 12.30.0-
beta.1 beta.1

Storage - Blobs NIO Maven 12.0.0- docs GitHub 12.0.0-

beta.31 beta.31

Storage - Files Data Lake Maven 12.23.0 docs GitHub 12.23.0

Maven 12.24.0- GitHub 12.24.0-
beta.1 beta.1

Storage - Files Share Maven 12.26.0 docs GitHub 12.26.0

Maven 12.27.0- GitHub 12.27.0-
beta.1 beta.1

Storage - Internal Avro Maven 12.15.0 docs GitHub 12.15.0

Maven 12.16.0- GitHub 12.16.0-
beta.1 beta.1
Name Package Docs Source

Storage - Queues Maven 12.25.0 docs GitHub 12.25.0

Maven 12.26.0- GitHub 12.26.0-
beta.1 beta.1

Synapse - AccessControl Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4

Synapse - Artifacts Maven 1.0.0- docs GitHub 1.0.0-

beta.16 beta.16

Synapse - Managed Private Endpoints Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

Synapse - Monitoring Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Synapse - Spark Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

System Events Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Tables Maven 12.5.3 docs GitHub 12.5.3

Text Analytics Maven 5.5.6 docs GitHub 5.5.6

Text Translation Maven 1.1.2 docs GitHub 1.1.2

Video Analyzer Edge Maven 1.0.0- docs GitHub 1.0.0-

beta.6 beta.6

Web PubSub Maven 1.4.1 docs GitHub 1.4.1

Web PubSub Client Maven 1.1.1 docs GitHub 1.1.1

Cosmos DB Encryption Maven 2.20.0 docs GitHub 2.20.0

OLTP Spark 3.1 Connector for Azure Cosmos DB SQL Maven 4.37.1 docs GitHub 4.37.1
API

OLTP Spark 3.2 Connector for Azure Cosmos DB SQL Maven 4.37.1 docs GitHub 4.37.1
API

OLTP Spark 3.3 Connector for Azure Cosmos DB SQL Maven 4.37.2 GitHub 4.37.2
API

SDK - Bill of Materials Maven 1.2.35 GitHub 1.2.35

Storage - Common Maven 12.29.0 docs GitHub 12.29.0

Maven 12.30.0- GitHub 12.30.0-
Name Package Docs Source

beta.1 beta.1

Core - Management - Core Maven 1.17.0 docs GitHub 1.17.0

Resource Management Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Advisor Maven 1.0.0 docs GitHub 1.0.0

Resource Management - AgriFood Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Alerts Management Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - API Center Maven 1.1.0 docs GitHub 1.1.0

Resource Management - API Management Maven 2.0.0 docs GitHub 2.0.0

Resource Management - App Compliance Automation Maven 1.0.0 docs GitHub 1.0.0

Resource Management - App Configuration Maven 1.0.0 docs GitHub 1.0.0

Resource Management - App Platform Maven 2.50.1 docs GitHub 2.50.1

Resource Management - App Service Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Application Insights Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Resource Management - Arc Data Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Arize AI Observability Eval Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Resource Management - Astro Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Attestation Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Authorization Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Automanage Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Automation Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Azure AI Search Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Azure Stack Maven 1.0.0 docs GitHub 1.0.0

Name Package Docs Source

Resource Management - Azure Stack HCI Maven 1.0.0- docs GitHub 1.0.0-
beta.5 beta.5

Resource Management - Azure VMware Solution Maven 1.2.0 docs GitHub 1.2.0

Resource Management - BareMetal Infrastructure Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Batch Maven 2.0.0 docs GitHub 2.0.0

Resource Management - Batch AI Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Billing Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Billing Benefits Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Bot Service Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Carbonoptimization Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Change Analysis Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Chaos Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Cognitive Services Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Resource Management - Commerce Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Communication Maven 2.2.0 docs GitHub 2.2.0

Resource Management - Compute Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Compute Fleet Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Compute Schedule Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Confidential Ledger Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1

Resource Management - Confluent Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Connected Cache Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Connected VMware Maven 1.1.0 docs GitHub 1.1.0

Name Package Docs Source

Resource Management - Consumption Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Container Apps Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Container Instances Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Container Orchestrator Maven 1.0.0- docs GitHub 1.0.0-

Runtime beta.1 beta.1

Resource Management - Container Registry Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Container Service Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Container Service Fleet Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Content Delivery Network Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Cosmos DB Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Cosmos DB for PostgreSQL Maven 1.0.0 docs GitHub 1.0.0
Maven 1.1.0- GitHub 1.1.0-
beta.2 beta.2

Resource Management - Cost Management Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Customer Insights Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Data Box Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Data Box Edge Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Factory Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Data Lake Analytics Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Lake Store Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Migration Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Protection Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Database Watcher Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Databricks Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Datadog Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Defender EASM Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2
Name Package Docs Source

Resource Management - Delegated Network Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Dependencymap Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Deployment Manager Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Desktop Virtualization Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Dev Center Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Dev Spaces Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - DevHub Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Device Provisioning Services Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Device Registry Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Device Update Maven 1.1.0 docs GitHub 1.1.0

Resource Management - DevOps Infrastructure Maven 1.0.0 docs GitHub 1.0.0

Resource Management - DevTest Labs Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Digital Twins Maven 1.3.0 docs GitHub 1.3.0

Resource Management - DNS Maven 2.51.0 docs GitHub 2.51.0

Resource Management - DNS Resolver Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Durable Task Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Dynatrace Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Edge Order Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Edge Zones Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Education Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4

Resource Management - Elastic Maven 1.0.0 docs GitHub 1.0.0

Name Package Docs Source

Resource Management - Elastic SAN Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0- GitHub 1.2.0-
beta.2 beta.2

Resource Management - Event Grid Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Event Hubs Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Extended Location Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Fabric Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Fluid Relay Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Front Door Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Graph Services Maven 1.1.0 docs GitHub 1.1.0

Resource Management - HANA on Azure Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Hardware Security Module Maven 1.0.0 docs GitHub 1.0.0

Resource Management - HDInsight Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.2 beta.2

Resource Management - HDInsight Containers Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Health Bot Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Health Data AI Services Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Healthcare APIs Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Hybrid Compute Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1

Resource Management - Hybrid Connectivity Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Resource Management - Hybrid Container Service Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Hybrid Kubernetes Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.1 beta.1
Name Package Docs Source

Resource Management - Hybrid Network Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Image Builder Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Impact Reporting Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Informatica Data Maven 1.0.0 docs GitHub 1.0.0

Management

Resource Management - IoT Central Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.2 beta.2

Resource Management - IoT Firmware Defense Maven 1.1.0 docs GitHub 1.1.0

Resource Management - IoT Hub Maven 1.3.0 docs GitHub 1.3.0

Resource Management - IoT Operations Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Key Vault Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Kubernetes Configuration Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Kubernetesconfiguration- Maven 1.0.0- docs GitHub 1.0.0-

Extensions beta.1 beta.1

Resource Management - Kubernetesconfiguration- Maven 1.0.0- docs GitHub 1.0.0-

Extensiontypes beta.1 beta.1

Resource Management - Kubernetesconfiguration- Maven 1.0.0- docs GitHub 1.0.0-

Fluxconfigurations beta.1 beta.1

Resource Management - Kusto Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Lab Services Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Lambdatesthyperexecute Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Large Instance Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Load Testing Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Load Testing Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Log Analytics Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Logic Apps Maven 1.0.0 docs GitHub 1.0.0

Name Package Docs Source

Resource Management - Logz Maven 1.0.0- docs GitHub 1.0.0-

beta.4 beta.4

Resource Management - Machine Learning Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Machine Learning Services Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Resource Management - Maintenance Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.2 beta.2

Resource Management - Managed Applications Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Managed Grafana Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Managed Network Fabric Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Managed Service Identity Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Management Groups Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Maps Maven 1.1.0 docs GitHub 1.1.0

Resource Management - MariaDB Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Marketplace Ordering Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Media Services Maven 2.4.0 docs GitHub 2.4.0

Resource Management - Migration Assessment Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Migration Discovery SAP Maven 1.0.0- docs GitHub 1.0.0-
beta.2 beta.2

Resource Management - Mixed Reality Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Mobile Network Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Mongo Cluster Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Mongodbatlas Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Monitor Maven 2.51.0 docs GitHub 2.51.0

Resource Management - MySQL Maven 1.0.2 docs GitHub 1.0.2

Resource Management - MySQL Flexible Server Maven 1.0.0 docs GitHub 1.0.0
Name Package Docs Source

Resource Management - Neon Postgres Maven 1.0.0 docs GitHub 1.0.0

Resource Management - NetApp Files Maven 1.7.0 docs GitHub 1.7.0

Maven 1.8.0- GitHub 1.8.0-
beta.1 beta.1

Resource Management - Network Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Network Analytics Maven 1.0.1 docs GitHub 1.0.1

Resource Management - Network Cloud Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Resource Management - Network Function Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - New Relic Observability Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Nginx Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.3 beta.3

Resource Management - Notification Hubs Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Open Energy Platform Maven 1.0.0- docs GitHub 1.0.0-
beta.2 beta.2

Resource Management - Operations Management Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Oracle Database Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Orbital Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Palo Alto Networks - Next Maven 1.2.0 docs GitHub 1.2.0
Generation Firewall

Resource Management - Peering Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Pinecone Vector DB Maven 1.0.0- docs GitHub 1.0.0-

beta.2 beta.2

Resource Management - Playwright Testing Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Policy Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Portalservicescopilot Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1
Name Package Docs Source

Resource Management - PostgreSQL Maven 1.1.0 docs GitHub 1.1.0

Resource Management - PostgreSQL Flexible Server Maven 1.1.0 docs GitHub 1.1.0
Maven 1.2.0- GitHub 1.2.0-
beta.1 beta.1

Resource Management - Power BI Dedicated Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Private DNS Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Provider Hub Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Purview Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Quantum Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Qumulo Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Quota Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Recovery Services Maven 1.4.0 docs GitHub 1.4.0

Resource Management - Recovery Services Backup Maven 1.6.0 docs GitHub 1.6.0

Resource Management - Recovery Services Data Maven 1.0.0- docs GitHub 1.0.0-
Replication beta.2 beta.2

Resource Management - Recovery Services Site Maven 1.3.0 docs GitHub 1.3.0
Recovery

Resource Management - Red Hat OpenShift Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Resource Management - Redis Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Redis Enterprise Maven 2.0.0 docs GitHub 2.0.0

Maven 2.1.0- GitHub 2.1.0-
beta.3 beta.3

Resource Management - Relay Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Reservations Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Resource Connector Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Resource Graph Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Resource Health Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.3 beta.3
Name Package Docs Source

Resource Management - Resource Mover Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Resources Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Secretsstoreextension Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Security Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Security DevOps Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Security Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Self Help Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0- GitHub 1.1.0-
beta.5 beta.5

Resource Management - Service Bus Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Service Fabric Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Service Fabric Managed Maven 1.0.0 docs GitHub 1.0.0
Clusters

Resource Management - Service Linker Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Service Networking Maven 1.1.0 docs GitHub 1.1.0

Resource Management - SignalR Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Sitemanager Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Sphere Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Spring App Discovery Maven 1.0.0- docs GitHub 1.0.0-
beta.2 beta.2

Resource Management - SQL Maven 2.51.0 docs GitHub 2.51.0

Resource Management - SQL Virtual Machine Maven 1.0.0- docs GitHub 1.0.0-
beta.5 beta.5

Resource Management - Standby Pool Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Storage Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Storage Actions Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3
Name Package Docs Source

Resource Management - Storage Cache Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Storage Import/Export Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

Resource Management - Storage Mover Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Storage Pool Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Stream Analytics Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Subscriptions Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Support Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Synapse Maven 1.0.0 docs GitHub 1.0.0

Resource Management - System Center Virtual Maven 1.0.0 docs GitHub 1.0.0
Machine Manager

Resource Management - Terraform Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Time Series Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Traffic Manager Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Trusted Signing Maven 1.0.0- docs GitHub 1.0.0-

beta.1 beta.1

Resource Management - Video Analyzer Maven 1.0.0- docs GitHub 1.0.0-

beta.5 beta.5

Resource Management - VMware Solution by Maven 1.0.0- docs GitHub 1.0.0-

CloudSimple beta.3 beta.3

Resource Management - Voice Services Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Web PubSub Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Weights & Biases Maven 1.0.0- docs GitHub 1.0.0-
beta.1 beta.1

Resource Management - Workloads Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Workloads SAP Virtual Maven 1.0.0 docs GitHub 1.0.0
Instance

Azure Identity Spring Maven 1.14.0 GitHub 1.14.0

Azure Spring Boot BOM Maven 4.0.0 GitHub 4.0.0

Name Package Docs Source

Azure Spring Boot Starter Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Active Directory Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Active Directory B2C Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Cosmos Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Key Vault Certificates Maven 3.14.0 GitHub 3.14.0

Azure Spring Boot Starter Key Vault Secrets Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Service bus Jms Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Storage Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Appconfiguration Config Maven 2.11.0 GitHub 2.11.0

Azure Spring Cloud Appconfiguration Config Web Maven 2.11.0 docs GitHub 2.11.0

Azure Spring Cloud Autoconfigure Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Context Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Dependencies Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Feature Management Maven 2.10.0 docs GitHub 2.10.0

Azure Spring Cloud Feature Management Web Maven 2.10.0 docs GitHub 2.10.0

Azure Spring Cloud Integration Core Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Service Bus Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Storage Queue Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Test Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Messaging Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Starter Appconfiguration Config Maven 2.11.0 docs GitHub 2.11.0

Azure Spring Cloud Starter Cache Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Starter Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Starter Event Hubs Kafka Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Starter Service bus Maven 4.0.0 GitHub 4.0.0
Name Package Docs Source

Azure Spring Cloud Starter Storage Queue Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Storage Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Stream Binder Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Stream Binder Service bus Core Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Stream Binder Service bus Queue Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Stream Binder Service bus Topic Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Stream Binder Test Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Telemetry Maven 2.5.0 GitHub 2.5.0

Key Vault - JCA Maven 2.10.1 GitHub 2.10.1

Spring Azure Docker Compose Maven 5.22.0 GitHub 5.22.0

Spring Azure Starter KeyVault JCA Maven 5.22.0 GitHub 5.22.0

Spring Cloud Azure Actuator Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Actuator AutoConfigure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Appconfiguration Config Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.1 beta.1

Spring Cloud Azure Appconfiguration Config Web Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.1 beta.1

Spring Cloud Azure Autoconfigure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Core Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Dependencies Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4
Name Package Docs Source

Spring Cloud Azure Feature Management Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.1 beta.1

Spring Cloud Azure Feature Management Web Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.1 beta.1

Spring Cloud Azure Native Configuration Maven 4.0.0- GitHub 4.0.0-

beta.1 beta.1

Spring Cloud Azure Resource Manager Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Service Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Active Directory Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Active Directory B2C Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Actuator Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter App Configuration Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Cosmos DB Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Data Cosmos DB Maven 5.22.0 GitHub 5.22.0

Spring Cloud Azure Starter Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4
Name Package Docs Source

Spring Cloud Azure Starter Integration Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Integration Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Integration Storage Queue Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Key Vault Certificates Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Key Vault Secrets Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Service Bus JMS Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Storage Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Storage Blob Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Storage File Share Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Storage Queue Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Stream Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Starter Stream Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
Name Package Docs Source

beta.4 beta.4

Spring Cloud Azure Stream Binder Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Stream Binder Event Hubs Core Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Stream Binder Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Stream Binder Service Bus Core Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Cloud Azure Trace on Sleuth Maven 4.20.0 GitHub 4.20.0

Maven 6.0.0- GitHub 6.0.0-
beta.2 beta.2

Spring Cloud Integration Azure Core Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Data Cosmos Maven 5.22.0 docs GitHub 5.22.0

Spring Integration Azure Event Hubs Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Integration Azure Service Bus Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Integration Azure Storage Queue Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Messaging Azure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Messaging Azure Event Hubs Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Messaging Azure Service Bus Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
Name Package Docs Source

beta.4 beta.4

Spring Messaging Azure Storage Queue Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

Spring Test Containers Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-appconfiguration-config Maven 5.22.0 docs GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.1 beta.1

spring-cloud-azure-starter-data-redis-lettuce Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-eventgrid Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-jdbc-mysql Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

spring-cloud-azure-starter-jdbc-postgresql Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

spring-cloud-azure-starter-keyvault Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0- GitHub 6.0.0-
beta.4 beta.4

spring-cloud-azure-starter-monitor Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-redis Maven 4.20.0 GitHub 4.20.0

azure-aot-graalvm-support Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

azure-aot-graalvm-support-netty Maven 1.0.0- docs GitHub 1.0.0-

beta.3 beta.3

All libraries
ﾉ Expand table

Name Package Docs Source

JDBC Authentication Plugin for MySQL Maven 1.0.0-beta.1 docs GitHub 1.0.0-
beta.1
Name Package Docs Source

JDBC Authentication Plugin for PostgreSQL Maven 1.0.0-beta.1 docs GitHub 1.0.0-
beta.1

Token-as-password Authentication Core Library Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Token-as-password Authentication Extensions Maven 1.2.2 docs GitHub 1.2.2

AI Agents Persistent Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

AI Projects Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

App Configuration Maven 1.8.0 docs GitHub 1.8.0

Attestation Maven 1.1.32 docs GitHub 1.1.32

Azure AI Inference Maven 1.0.0-beta.5 docs GitHub 1.0.0-

beta.5

Azure AI Search Maven 11.7.6 docs GitHub 11.7.6

Maven 11.8.0-beta.7 GitHub 11.8.0-
beta.7

Azure Blob Storage Checkpoint Store Maven 1.20.7 docs GitHub 1.20.7
Maven 1.21.0-beta.1 GitHub 1.21.0-
beta.1

Azure Maps Geolocation Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Azure Maps TimeZone Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Azure Maps Traffic Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Azure Maps Weather Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Azure Redis Checkpoint Store Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Azure Remote Rendering Maven 1.1.37 docs GitHub 1.1.37

azure-core-http-jdk-httpclient Maven 1.0.3 docs GitHub 1.0.3

azure-core-http-vertx Maven 1.0.3 docs GitHub 1.0.3

Name Package Docs Source

azure-core-metrics-opentelemetry Maven 1.0.0-beta.29 docs GitHub 1.0.0-

beta.29

azure-json Maven 1.5.0 docs GitHub 1.5.0

azure-sdk-archetype Maven 1.0.0 GitHub 1.0.0

azure-sdk-build-tool Maven 1.0.0 docs GitHub 1.0.0

azure-xml Maven 1.2.0 docs GitHub 1.2.0

Calling Server Maven 1.0.0-beta.4 docs GitHub 1.0.0-

beta.4

Communication Call Automation Maven 1.4.0 docs GitHub 1.4.0

Communication Chat Maven 1.5.9 docs GitHub 1.5.9

Communication Common Maven 1.3.11 docs GitHub 1.3.11

Maven 2.0.0-beta.1 GitHub 2.0.0-
beta.1

Communication Email Maven 1.0.21 docs GitHub 1.0.21

Maven 1.1.0-beta.1 GitHub 1.1.0-
beta.1

Communication Identity Maven 1.6.4 docs GitHub 1.6.4

Communication JobRouter Maven 1.1.12 docs GitHub 1.1.12

Communication Messages Maven 1.1.3 docs GitHub 1.1.3

Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Communication Phone Numbers Maven 1.2.2 docs GitHub 1.2.2

Maven 1.3.0-beta.1 GitHub 1.3.0-
beta.1

Communication Rooms Maven 1.2.0 docs GitHub 1.2.0

Communication Sms Maven 1.1.32 docs GitHub 1.1.32

Compute Batch Maven 1.0.0-beta.4 docs GitHub 1.0.0-

beta.4

Confidential Ledger Maven 1.0.28 docs GitHub 1.0.28

Maven 1.1.0-beta.1 GitHub 1.1.0-
beta.1

Container Registry Maven 1.2.16 docs GitHub 1.2.16

Name Package Docs Source

Content Safety Maven 1.0.11 docs GitHub 1.0.11

Core - Client - AMQP Maven 2.9.16 docs GitHub 2.9.16

Core - Client - Core Maven 1.55.3 docs GitHub 1.55.3

Core - Client - Core Experimental Maven 1.0.0-beta.60 docs GitHub 1.0.0-

beta.60

Core - Client - Core Serializer Apache Avro Maven 1.0.0-beta.56 docs GitHub 1.0.0-
beta.56

Core - Client - Core Serializer GSON JSON Maven 1.3.8 docs GitHub 1.3.8

Core - Client - Core Serializer Jackson JSON Maven 1.5.8 docs GitHub 1.5.8

Core - Client - HTTP Netty Maven 1.15.11 docs GitHub 1.15.11

Core - Client - HTTP OkHttp Maven 1.12.10 docs GitHub 1.12.10

Core - Client - Test Maven 1.26.2 docs GitHub 1.26.2

Maven 1.27.0-beta.8 GitHub 1.27.0-
beta.8

Core - Plugin - Tracing OpenTelemetry Plugin Maven 1.0.0-beta.56 docs GitHub 1.0.0-
beta.56

Cosmos DB Maven 4.71.0 docs GitHub 4.71.0

Cosmos Kafka Connect Maven 2.3.1 GitHub 2.3.1

Cosmos Spark 3.4 Maven 4.37.2 GitHub 4.37.2

Cosmos Spark 3.5 Maven 4.37.2 GitHub 4.37.2

Cosmos Test Maven 1.0.0-beta.12 docs GitHub 1.0.0-

beta.12

Defender EASM Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Dev Center Maven 1.0.8 docs GitHub 1.0.8

Device Update Maven 1.0.26 docs GitHub 1.0.26

Digital Twins Maven 1.4.2 docs GitHub 1.4.2

Document Intelligence Maven 1.0.1 docs GitHub 1.0.1

Document Translation Maven 1.0.1 docs GitHub 1.0.1

Name Package Docs Source

Event Grid Maven 4.30.0 docs GitHub 4.30.0

Event Grid Namespaces Maven 1.1.3 docs GitHub 1.1.3

Event Hubs Maven 5.20.3 docs GitHub 5.20.3

Maven 5.21.0-beta.1 GitHub 5.21.0-
beta.1

Face Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

FarmBeats Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Form Recognizer Maven 4.1.13 docs GitHub 4.1.13

Health Deidentification Maven 1.0.0 docs GitHub 1.0.0

Health Insights Cancer Profiling Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Health Insights Clinical Matching Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Health Insights Radiology Insights Maven 1.1.0 docs GitHub 1.1.0

Identity Maven 1.16.1 docs GitHub 1.16.1

Identity Broker Maven 1.1.14 docs GitHub 1.1.14

Image Analysis Maven 1.0.1 docs GitHub 1.0.1

Key Vault - Administration Maven 4.6.4 docs GitHub 4.6.4

Maven 4.7.0-beta.1 GitHub 4.7.0-
beta.1

Key Vault - Certificates Maven 4.7.4 docs GitHub 4.7.4

Maven 4.8.0-beta.1 GitHub 4.8.0-
beta.1

Key Vault - Keys Maven 4.9.4 docs GitHub 4.9.4

Maven 4.10.0-beta.1 GitHub 4.10.0-
beta.1

Key Vault - Secrets Maven 4.9.4 docs GitHub 4.9.4

Maven 4.10.0-beta.1 GitHub 4.10.0-
beta.1

Load Testing Maven 1.0.22 docs GitHub 1.0.22

Maven 1.1.0-beta.1 GitHub 1.1.0-
Name Package Docs Source

beta.1

Maps Render Maven 2.0.0-beta.2 docs GitHub 2.0.0-

beta.2

Maps Route Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Maps Search Maven 2.0.0-beta.2 docs GitHub 2.0.0-

beta.2

Metrics Advisor Maven 1.2.6 docs GitHub 1.2.6

Mixed Reality Authentication Maven 1.2.32 docs GitHub 1.2.32

Models Repository Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Monitor Ingestion Maven 1.2.9 docs GitHub 1.2.9

Monitor Query Maven 1.5.7 docs GitHub 1.5.7

OpenAI Maven 1.0.0-beta.16 docs GitHub 1.0.0-

beta.16

OpenAI Assistants Maven 1.0.0-beta.5 docs GitHub 1.0.0-

beta.5

OpenTelemetry AutoConfigure Maven 1.2.0 docs GitHub 1.2.0

OpenTelemetry Exporter Maven 1.0.0-beta.32 docs GitHub 1.0.0-

beta.32

Purview Account Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Purview Administration Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Purview Data Map Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Purview Scanning Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Purview Sharing Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Purview Workflow Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2
Name Package Docs Source

Quantum Jobs Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Schema Registry Maven 1.5.4 docs GitHub 1.5.4

Schema Registry - Avro Maven 1.1.25 docs GitHub 1.1.25

Maven 1.2.0-beta.2 GitHub 1.2.0-
beta.2

Schema Registry - Avro Maven 1.0.0-beta.5 docs GitHub 1.0.0-

beta.5

Schema Registry - JSON Maven 1.0.1 docs GitHub 1.0.1

Service Bus Maven 7.17.11 docs GitHub 7.17.11

Maven 7.18.0-beta.1 GitHub 7.18.0-
beta.1

Storage - Blobs Maven 12.30.0 docs GitHub 12.30.0

Maven 12.31.0-beta.1 GitHub 12.31.0-
beta.1

Storage - Blobs Batch Maven 12.26.0 docs GitHub 12.26.0

Maven 12.27.0-beta.1 GitHub 12.27.0-
beta.1

Storage - Blobs Changefeed Maven 12.0.0-beta.30 docs GitHub 12.0.0-

beta.30

Storage - Blobs Cryptography Maven 12.29.0 docs GitHub 12.29.0

Maven 12.30.0-beta.1 GitHub 12.30.0-
beta.1

Storage - Blobs NIO Maven 12.0.0-beta.31 docs GitHub 12.0.0-

beta.31

Storage - Files Data Lake Maven 12.23.0 docs GitHub 12.23.0

Maven 12.24.0-beta.1 GitHub 12.24.0-
beta.1

Storage - Files Share Maven 12.26.0 docs GitHub 12.26.0

Maven 12.27.0-beta.1 GitHub 12.27.0-
beta.1

Storage - Internal Avro Maven 12.15.0 docs GitHub 12.15.0

Maven 12.16.0-beta.1 GitHub 12.16.0-
beta.1

Storage - Queues Maven 12.25.0 docs GitHub 12.25.0

Maven 12.26.0-beta.1 GitHub 12.26.0-
Name Package Docs Source

beta.1

Synapse - AccessControl Maven 1.0.0-beta.4 docs GitHub 1.0.0-

beta.4

Synapse - Artifacts Maven 1.0.0-beta.16 docs GitHub 1.0.0-

beta.16

Synapse - Managed Private Endpoints Maven 1.0.0-beta.5 docs GitHub 1.0.0-

beta.5

Synapse - Monitoring Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Synapse - Spark Maven 1.0.0-beta.5 docs GitHub 1.0.0-

beta.5

System Events Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Tables Maven 12.5.3 docs GitHub 12.5.3

Text Analytics Maven 5.5.6 docs GitHub 5.5.6

Text Translation Maven 1.1.2 docs GitHub 1.1.2

Web PubSub Maven 1.4.1 docs GitHub 1.4.1

Web PubSub Client Maven 1.1.1 docs GitHub 1.1.1

Cosmos DB Encryption Maven 2.20.0 docs GitHub 2.20.0

OLTP Spark 3.1 Connector for Azure Cosmos DB Maven 4.37.1 docs GitHub 4.37.1
SQL API

OLTP Spark 3.2 Connector for Azure Cosmos DB Maven 4.37.1 docs GitHub 4.37.1
SQL API

OLTP Spark 3.3 Connector for Azure Cosmos DB Maven 4.37.2 GitHub 4.37.2
SQL API

SDK - Bill of Materials Maven 1.2.35 GitHub 1.2.35

Storage - Common Maven 12.29.0 docs GitHub 12.29.0

Maven 12.30.0-beta.1 GitHub 12.30.0-
beta.1

Core - Management - Core Maven 1.17.0 docs GitHub 1.17.0

Resource Management Maven 2.51.0 docs GitHub 2.51.0

Name Package Docs Source

Resource Management - Advisor Maven 1.0.0 docs GitHub 1.0.0

Resource Management - AgriFood Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Alerts Management Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - API Center Maven 1.1.0 docs GitHub 1.1.0

Resource Management - API Management Maven 2.0.0 docs GitHub 2.0.0

Resource Management - App Compliance Maven 1.0.0 docs GitHub 1.0.0

Automation

Resource Management - App Configuration Maven 1.0.0 docs GitHub 1.0.0

Resource Management - App Platform Maven 2.50.1 docs GitHub 2.50.1

Resource Management - App Service Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Application Insights Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Resource Management - Arc Data Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Arize AI Observability Maven 1.0.0-beta.1 docs GitHub 1.0.0-

Eval beta.1

Resource Management - Astro Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Attestation Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Authorization Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Automanage Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Automation Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Azure AI Search Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Azure Stack Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Azure Stack HCI Maven 1.0.0-beta.5 docs GitHub 1.0.0-
beta.5

Resource Management - Azure VMware Solution Maven 1.2.0 docs GitHub 1.2.0
Name Package Docs Source

Resource Management - BareMetal Infrastructure Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Batch Maven 2.0.0 docs GitHub 2.0.0

Resource Management - Billing Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Billing Benefits Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Bot Service Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Carbonoptimization Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Change Analysis Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Chaos Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Cognitive Services Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Resource Management - Commerce Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Communication Maven 2.2.0 docs GitHub 2.2.0

Resource Management - Compute Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Compute Fleet Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Compute Schedule Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Confidential Ledger Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.1 GitHub 1.1.0-
beta.1

Resource Management - Confluent Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Connected Cache Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Connected VMware Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Consumption Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Container Apps Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Container Instances Maven 2.51.0 docs GitHub 2.51.0

Name Package Docs Source

Resource Management - Container Orchestrator Maven 1.0.0-beta.1 docs GitHub 1.0.0-

Runtime beta.1

Resource Management - Container Registry Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Container Service Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Container Service Fleet Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Content Delivery Maven 2.51.0 docs GitHub 2.51.0

Network

Resource Management - Cosmos DB Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Cosmos DB for Maven 1.0.0 docs GitHub 1.0.0

PostgreSQL Maven 1.1.0-beta.2 GitHub 1.1.0-
beta.2

Resource Management - Cost Management Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Customer Insights Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Data Box Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Data Box Edge Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Factory Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Data Lake Analytics Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Lake Store Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Migration Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Data Protection Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Database Watcher Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Databricks Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Datadog Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Defender EASM Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Delegated Network Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3
Name Package Docs Source

Resource Management - Dependencymap Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Deployment Manager Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Desktop Virtualization Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Dev Center Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Dev Spaces Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - DevHub Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Device Provisioning Maven 1.1.0 docs GitHub 1.1.0

Services

Resource Management - Device Registry Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Device Update Maven 1.1.0 docs GitHub 1.1.0

Resource Management - DevOps Infrastructure Maven 1.0.0 docs GitHub 1.0.0

Resource Management - DevTest Labs Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Digital Twins Maven 1.3.0 docs GitHub 1.3.0

Resource Management - DNS Maven 2.51.0 docs GitHub 2.51.0

Resource Management - DNS Resolver Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Durable Task Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Dynatrace Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Edge Order Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Edge Zones Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Education Maven 1.0.0-beta.4 docs GitHub 1.0.0-

beta.4

Resource Management - Elastic Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Elastic SAN Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0-beta.2 GitHub 1.2.0-
beta.2
Name Package Docs Source

Resource Management - Event Grid Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Event Hubs Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Extended Location Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Fabric Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Fluid Relay Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Front Door Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Graph Services Maven 1.1.0 docs GitHub 1.1.0

Resource Management - HANA on Azure Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Hardware Security Maven 1.0.0 docs GitHub 1.0.0

Module

Resource Management - HDInsight Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.2 GitHub 1.1.0-
beta.2

Resource Management - HDInsight Containers Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Health Bot Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Health Data AI Services Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Healthcare APIs Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Hybrid Compute Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.1 GitHub 1.1.0-
beta.1

Resource Management - Hybrid Connectivity Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Resource Management - Hybrid Container Service Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Hybrid Kubernetes Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.1 GitHub 1.1.0-
beta.1

Resource Management - Hybrid Network Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Image Builder Maven 1.2.0 docs GitHub 1.2.0

Name Package Docs Source

Resource Management - Impact Reporting Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Informatica Data Maven 1.0.0 docs GitHub 1.0.0

Management

Resource Management - IoT Central Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.2 GitHub 1.1.0-
beta.2

Resource Management - IoT Firmware Defense Maven 1.1.0 docs GitHub 1.1.0

Resource Management - IoT Hub Maven 1.3.0 docs GitHub 1.3.0

Resource Management - IoT Operations Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Key Vault Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Kubernetes Maven 1.1.0 docs GitHub 1.1.0

Configuration

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-

Kubernetesconfiguration-Extensions beta.1

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-

Kubernetesconfiguration-Extensiontypes beta.1

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-

Kubernetesconfiguration-Fluxconfigurations beta.1

Resource Management - Kusto Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Lab Services Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Lambdatesthyperexecute Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Large Instance Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Load Testing Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Log Analytics Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Logic Apps Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Machine Learning Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Maintenance Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.2 GitHub 1.1.0-
Name Package Docs Source

beta.2

Resource Management - Managed Applications Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Managed Grafana Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Managed Network Fabric Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Managed Service Identity Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Management Groups Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Maps Maven 1.1.0 docs GitHub 1.1.0

Resource Management - MariaDB Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Marketplace Ordering Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Media Services Maven 2.4.0 docs GitHub 2.4.0

Resource Management - Migration Assessment Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Migration Discovery SAP Maven 1.0.0-beta.2 docs GitHub 1.0.0-
beta.2

Resource Management - Mixed Reality Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Mobile Network Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Mongo Cluster Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Mongodbatlas Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Monitor Maven 2.51.0 docs GitHub 2.51.0

Resource Management - MySQL Maven 1.0.2 docs GitHub 1.0.2

Resource Management - MySQL Flexible Server Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Neon Postgres Maven 1.0.0 docs GitHub 1.0.0

Resource Management - NetApp Files Maven 1.7.0 docs GitHub 1.7.0

Maven 1.8.0-beta.1 GitHub 1.8.0-
beta.1

Resource Management - Network Maven 2.51.0 docs GitHub 2.51.0

Name Package Docs Source

Resource Management - Network Cloud Maven 1.1.0 docs GitHub 1.1.0

Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Resource Management - Network Function Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - New Relic Observability Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Nginx Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.3 GitHub 1.1.0-
beta.3

Resource Management - Notification Hubs Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Open Energy Platform Maven 1.0.0-beta.2 docs GitHub 1.0.0-
beta.2

Resource Management - Operations Management Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Oracle Database Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Orbital Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Palo Alto Networks - Maven 1.2.0 docs GitHub 1.2.0
Next Generation Firewall

Resource Management - Peering Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Pinecone Vector DB Maven 1.0.0-beta.2 docs GitHub 1.0.0-

beta.2

Resource Management - Playwright Testing Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Policy Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Portalservicescopilot Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - PostgreSQL Maven 1.1.0 docs GitHub 1.1.0

Resource Management - PostgreSQL Flexible Maven 1.1.0 docs GitHub 1.1.0

Server Maven 1.2.0-beta.1 GitHub 1.2.0-
beta.1

Resource Management - Power BI Dedicated Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Private DNS Maven 2.51.0 docs GitHub 2.51.0

Name Package Docs Source

Resource Management - Provider Hub Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Purview Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Quantum Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Qumulo Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Quota Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Recovery Services Maven 1.4.0 docs GitHub 1.4.0

Resource Management - Recovery Services Backup Maven 1.6.0 docs GitHub 1.6.0

Resource Management - Recovery Services Data Maven 1.0.0-beta.2 docs GitHub 1.0.0-
Replication beta.2

Resource Management - Recovery Services Site Maven 1.3.0 docs GitHub 1.3.0
Recovery

Resource Management - Red Hat OpenShift Maven 1.0.0-beta.1 docs GitHub 1.0.0-
beta.1

Resource Management - Redis Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Redis Enterprise Maven 2.0.0 docs GitHub 2.0.0

Maven 2.1.0-beta.3 GitHub 2.1.0-
beta.3

Resource Management - Relay Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Reservations Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Resource Connector Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Resource Graph Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Resource Health Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.3 GitHub 1.1.0-
beta.3

Resource Management - Resource Mover Maven 1.2.0 docs GitHub 1.2.0

Resource Management - Resources Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Secretsstoreextension Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Security Maven 1.0.0 docs GitHub 1.0.0

Name Package Docs Source

Resource Management - Security DevOps Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Security Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Self Help Maven 1.0.0 docs GitHub 1.0.0

Maven 1.1.0-beta.5 GitHub 1.1.0-
beta.5

Resource Management - Service Bus Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Service Fabric Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Service Fabric Managed Maven 1.0.0 docs GitHub 1.0.0
Clusters

Resource Management - Service Linker Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Service Networking Maven 1.1.0 docs GitHub 1.1.0

Resource Management - SignalR Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Sitemanager Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Sphere Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Spring App Discovery Maven 1.0.0-beta.2 docs GitHub 1.0.0-
beta.2

Resource Management - SQL Maven 2.51.0 docs GitHub 2.51.0

Resource Management - SQL Virtual Machine Maven 1.0.0-beta.5 docs GitHub 1.0.0-
beta.5

Resource Management - Standby Pool Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Storage Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Storage Actions Maven 1.0.0-beta.3 docs GitHub 1.0.0-

beta.3

Resource Management - Storage Cache Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Storage Mover Maven 1.3.0 docs GitHub 1.3.0

Resource Management - Storage Pool Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Stream Analytics Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Subscriptions Maven 1.0.0 docs GitHub 1.0.0

Name Package Docs Source

Resource Management - Support Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Synapse Maven 1.0.0 docs GitHub 1.0.0

Resource Management - System Center Virtual Maven 1.0.0 docs GitHub 1.0.0
Machine Manager

Resource Management - Terraform Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - Time Series Insights Maven 1.0.0 docs GitHub 1.0.0

Resource Management - Traffic Manager Maven 2.51.0 docs GitHub 2.51.0

Resource Management - Trusted Signing Maven 1.0.0-beta.1 docs GitHub 1.0.0-

beta.1

Resource Management - VMware Solution by Maven 1.0.0-beta.3 docs GitHub 1.0.0-

CloudSimple beta.3

Resource Management - Voice Services Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Web PubSub Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Weights & Biases Maven 1.0.0-beta.1 docs GitHub 1.0.0-
beta.1

Resource Management - Workloads Maven 1.1.0 docs GitHub 1.1.0

Resource Management - Workloads SAP Virtual Maven 1.0.0 docs GitHub 1.0.0
Instance

Azure Identity Spring Maven 1.14.0 GitHub 1.14.0

Azure Spring Boot BOM Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Active Directory Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Active Directory B2C Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Cosmos Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Key Vault Certificates Maven 3.14.0 GitHub 3.14.0

Azure Spring Boot Starter Key Vault Secrets Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Service bus Jms Maven 4.0.0 GitHub 4.0.0

Azure Spring Boot Starter Storage Maven 4.0.0 GitHub 4.0.0

Name Package Docs Source

Azure Spring Cloud Appconfiguration Config Maven 2.11.0 GitHub 2.11.0

Azure Spring Cloud Appconfiguration Config Web Maven 2.11.0 docs GitHub 2.11.0

Azure Spring Cloud Autoconfigure Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Context Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Dependencies Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Feature Management Maven 2.10.0 docs GitHub 2.10.0

Azure Spring Cloud Feature Management Web Maven 2.10.0 docs GitHub 2.10.0

Azure Spring Cloud Integration Core Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Service Bus Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Storage Queue Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Integration Test Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Messaging Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Starter Appconfiguration Maven 2.11.0 docs GitHub 2.11.0
Config

Azure Spring Cloud Starter Cache Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Starter Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Starter Event Hubs Kafka Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Starter Service bus Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Starter Storage Queue Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Storage Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Stream Binder Event Hubs Maven 4.0.0 GitHub 4.0.0

Azure Spring Cloud Stream Binder Service bus Maven 4.0.0 GitHub 4.0.0
Core

Azure Spring Cloud Stream Binder Service bus Maven 4.0.0 GitHub 4.0.0
Queue

Azure Spring Cloud Stream Binder Service bus Maven 4.0.0 GitHub 4.0.0
Topic
Name Package Docs Source

Azure Spring Cloud Stream Binder Test Maven 2.14.0 GitHub 2.14.0

Azure Spring Cloud Telemetry Maven 2.5.0 GitHub 2.5.0

Key Vault - JCA Maven 2.10.1 GitHub 2.10.1

Spring Azure Docker Compose Maven 5.22.0 GitHub 5.22.0

Spring Azure Starter KeyVault JCA Maven 5.22.0 GitHub 5.22.0

Spring Cloud Azure Actuator Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Actuator AutoConfigure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Appconfiguration Config Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0-beta.1 GitHub 6.0.0-
beta.1

Spring Cloud Azure Appconfiguration Config Web Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0-beta.1 GitHub 6.0.0-
beta.1

Spring Cloud Azure Autoconfigure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Core Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Dependencies Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Feature Management Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0-beta.1 GitHub 6.0.0-
beta.1

Spring Cloud Azure Feature Management Web Maven 5.22.0 docs GitHub 5.22.0
Maven 6.0.0-beta.1 GitHub 6.0.0-
beta.1

Spring Cloud Azure Native Configuration Maven 4.0.0-beta.1 GitHub 4.0.0-

beta.1
Name Package Docs Source

Spring Cloud Azure Resource Manager Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Service Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Active Directory Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Active Directory B2C Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Actuator Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter App Configuration Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Cosmos DB Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Data Cosmos DB Maven 5.22.0 GitHub 5.22.0

Spring Cloud Azure Starter Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Integration Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Integration Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Integration Storage Maven 5.22.0 GitHub 5.22.0
Queue Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4
Name Package Docs Source

Spring Cloud Azure Starter Key Vault Certificates Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Key Vault Secrets Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Service Bus JMS Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Storage Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Storage Blob Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Storage File Share Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Storage Queue Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Stream Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Starter Stream Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Stream Binder Event Hubs Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Stream Binder Event Hubs Maven 5.22.0 GitHub 5.22.0
Core Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4
Name Package Docs Source

Spring Cloud Azure Stream Binder Service Bus Maven 5.22.0 GitHub 5.22.0
Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Stream Binder Service Bus Maven 5.22.0 GitHub 5.22.0
Core Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Cloud Azure Trace on Sleuth Maven 4.20.0 GitHub 4.20.0

Maven 6.0.0-beta.2 GitHub 6.0.0-
beta.2

Spring Cloud Integration Azure Core Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Data Cosmos Maven 5.22.0 docs GitHub 5.22.0

Spring Integration Azure Event Hubs Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Integration Azure Service Bus Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Integration Azure Storage Queue Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Messaging Azure Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Messaging Azure Event Hubs Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Messaging Azure Service Bus Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Messaging Azure Storage Queue Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

Spring Test Containers Maven 5.22.0 GitHub 5.22.0

Name Package Docs Source

spring-cloud-azure-starter-appconfiguration- Maven 5.22.0 docs GitHub 5.22.0

config Maven 6.0.0-beta.1 GitHub 6.0.0-
beta.1

spring-cloud-azure-starter-data-redis-lettuce Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-eventgrid Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-jdbc-mysql Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

spring-cloud-azure-starter-jdbc-postgresql Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

spring-cloud-azure-starter-keyvault Maven 5.22.0 GitHub 5.22.0

Maven 6.0.0-beta.4 GitHub 6.0.0-
beta.4

spring-cloud-azure-starter-monitor Maven 5.22.0 GitHub 5.22.0

spring-cloud-azure-starter-redis Maven 4.20.0 GitHub 4.20.0

azure-cosmos-cassandra-spring-data-extensions Maven 1.1.0

Maven 1.1.2-1

azure-functions-java-library-dapr Maven 1.0.1

azure-functions-java-library-kusto Maven 1.0.11-Preview

azure-gradle-plugins-common Maven 1.10.0

azure-kusto-log4j Maven 1.0.0

azure-mariadb-connector-java Maven 2.7.0

azure-microprofile-bom Maven 1.0.0-beta.3

azure-microprofile-config-keyvault Maven 1.0.0-beta.3

azure-microprofile-parent Maven 1.0.0-beta.3

azure-sdk-build-tool-maven-plugin Maven 1.0.0

azure-spring-apps-maven-plugin Maven 1.19.0

azure-toolkit-identity-lib Maven 0.53.0

azure-toolkit-keyvault-lib Maven 0.53.0

Name Package Docs Source

azureml-fs-scala-impl Maven 1.0.4

Container Apps Maven Plugin Maven 0.2.0

flink-connector-kusto Maven 1.0.2

Fuctions OpenAI Maven 0.5.0-preview

Functions - MySQL Maven 1.0.2

Functiosn - Java SDK Types Maven 1.0.1

hdi-oauth-token-utils Maven 1.0.2

HDInsights OAuth Token Utils Shaded Maven 1.0.2

Java Library Redis Maven 1.0.0

javamsalruntime Maven 0.17.4

JSON - GSON JSON Maven 1.0.0-beta.3

JSON - JSON Reflect Maven 1.0.0-beta.2

Kusto Spark Maven 5.0.0

Postgre Single Library Maven 0.53.0

Schema Registry - JSON Maven 1.0.0-beta.2

Service Bus -JMS Maven 2.0.0

Service Bus Library Maven 0.53.0

Service Linker Library Maven 0.53.0

Spring Cloud Azure Native Reachability Maven 5.0.0-beta.1

Spring Cloud Azure Starter - OpenAI Maven 4.9.0-beta.1

Spring Cloud Azure Stream Binder Test Maven 4.0.0-beta.2

Unknown Display Name Maven 1.0.0

Active Directory Authentication Library Maven 1.6.7 docs

Actors Maven 1.0.0

Application Insights - Agent Maven 3.7.3

Application Insights - Collectd Maven 2.6.4

Maven 2.6.3-BETA-
Name Package Docs Source

HEYA-TEST

Application Insights - Core Maven 3.7.3

Application Insights - Logging Log4j1_2 Maven 2.6.4

Application Insights - Logging Log4j2 Maven 2.6.4

Application Insights - Logging Logback Maven 2.6.4

Application Insights - Profiler Agent Maven 0.2.0

Application Insights - Profiler Library Maven 0.2.0

Application Insights - Profiler Telemetrymodule Maven 0.2.1

Application Insights - Profiler Uploader Maven 0.2.0

Application Insights - Spring Boot Starter Maven 2.6.4

Maven 2.6.3-BETA-
HEYA-TEST

Application Insights - Web Maven 3.7.3

Application Insights - Web Auto Maven 2.6.4

Maven 2.6.3-BETA-
HEYA-TEST

AutoRest Build Tools Maven 1.7.14

AutoRest Client Runtime for Java Maven 2.1.1

Azure AI Vision SDK - Common Maven 0.15.1-beta.1 GitHub 0.15.1-

beta.1

Azure AI Vision SDK - Internal Maven 0.15.1-beta.1 GitHub 0.15.1-

beta.1

Azure Functions Java Library RabbitMQ Maven 2.1.0

Azure Profile hybrid Maven 1.0.0-beta-1

azure-communication-administration Maven 1.0.0-beta.4

azure-schemaregistry-spark-avro Maven 1.0.1

azure-storage-fastpath Maven 1.0.0-beta.6

azure-toolkit-applicationinsights-lib Maven 0.53.0

Batch Maven 11.2.0 docs GitHub 11.2.0

Name Package Docs Source

Client Authentication Maven 1.7.14

Client Runtime Maven 1.7.14

Cognitive Services - Parent Maven 1.0.2

Confidential Ledger Maven 1.0.0-beta.1

Conversational Language Understanding Maven 0.0.1-beta

Core - Client - Legacy Maven 0.9.8 docs

Core - Parent Maven 1.0.0-preview.2

Core - Tracing OpenCensus Maven 1.0.0-preview.4 GitHub 1.0.0-

preview.4

Cosmos DB Maven 3.7.6 docs GitHub 3.7.6

Cosmos DB - Commons Maven 3.0.0-beta-3

Cosmos DB - Parent Maven 4.0.0-preview.2

Cosmos DB - Parent Maven 3.5.0

Digital Twins Device Client Preview Maven 1.0.0

Document DB - Spring Boot Auto Configure Maven 0.1.7

Document DB - Spring Boot Starter Maven 2.0.5

Durable Functions - Java Library Maven 1.0.1 GitHub 1.0.1

Event Hubs - Databricks Maven 3.4.0

Event Hubs - Parent Maven 5.0.0-preview.1

Event Hubs - Reactive Maven 0.5.0

Event Hubs - Spark Maven 2.3.22

Functions - Archetype Maven 1.64

Functions - Java Core Maven 1.0.0-beta-3

Functions - Java Library Maven 3.1.0

Maven 3.1.1-alpha

Functions - Java Library Cosmos DB Cassandra Maven 1.0.0

Functions - Java Library SignalR Maven 1.0.0

Name Package Docs Source

Functions - Kotlin Archetype Maven 1.23

Internet Analyzer Java Maven 1.0.0-beta.1

IoT Deps Maven 2.0.0-preview-

001

IoT Edge - Gateway - Java Binding Maven 1.1.0

IoT Edge - Gateway - Linux Maven 1.0.2

IoT Edge - Gateway - Module Base Maven 1.0.2

IoT Edge - Gateway - Module Simple Maven 1.0.0

IoT Edge - Gateway - Win32 Maven 1.0.2

IoT Edge Archetype Maven 1.3.0

IoT Hub - Security Provider Maven 2.0.1

Maven 2.0.0-preview-
001

IoT Hub - TPM Provider Maven 2.0.1

Maven 2.0.0-preview-
001

IoT Hub - X509 Provider Maven 2.0.2

Maven 2.0.0-preview-
001

IoT Plug and Play - Device Client Maven 2.5.0

Maven 2.0.0-preview-
002

IoT Service Client Maven 2.1.9 docs

Maven 2.0.0-preview-
002

Kusto Data Maven 6.0.2

Kusto Ingest Maven 6.0.2

Kusto Spark Maven 5.3.0

Media Services Maven 0.9.8 GitHub 0.9.8

Native Maven 1.0.0

Parent Maven 1.41.4

Name Package Docs Source

Profile - Parent Maven 1.0.0-beta-1 GitHub 1.0.0-beta-

1

Provisioning Device Client Maven 2.1.3

Maven 2.0.0-preview-
002

Provisioning Service Client Maven 2.0.3

Maven 2.0.1-preview-
001

Qpid Proton J Extensions Maven 1.2.5

Relay Maven 0.0.6

Service Fabric Maven 1.0.0

Service Runtime Maven 0.9.8

Speech Maven 1.28.1 GitHub 1.28.1

Spring Cloud Maven Plugin Maven 1.11.0

Spring Data Azure CosmosDB DocumentDB Maven 0.1.1

Spring Data Azure DocumentDB Maven 0.1.7

Spring Data Cosmos Core Maven 3.0.0-beta.1

Spring Data CosmosDB Maven 3.0.0.M1

Spring Data DocumentDB Maven 2.0.3

Storage - Files Data Lake Maven 2.3.10 docs

Storage - Java Maven 10

Support Maven 0.1.8

synapseml Maven 0.9.3

synapseml_2.12 Maven 1.0.11

synapseml-cognitive Maven 0.9.3

synapseml-cognitive_2.12 Maven 1.0.11

synapseml-core Maven 0.9.3

synapseml-core_2.12 Maven 1.0.11

Name Package Docs Source

synapseml-deep-learning Maven 0.9.3

synapseml-deep-learning_2.12 Maven 1.0.11

synapseml-lightgbm Maven 0.9.3

synapseml-lightgbm_2.12 Maven 1.0.11

synapseml-opencv Maven 0.9.3

synapseml-opencv_2.12 Maven 1.0.11

synapseml-vw Maven 0.9.3

synapseml-vw_2.12 Maven 1.0.11

synapseutils Maven 1.1

synapseutils_2.11 Maven 1.5.3

synapseutils_2.12 Maven 1.5.4

System Fabric Maven 1.0.0

TPM Software Stack Java Maven 1.0.0

Transport Maven 1.0.0

Websocket Transport Layer Maven 0.1.3

Annotations Maven 1.10.0

Apache Spark Archetype Maven 0.1.0

applicationinsights-runtime-attach Maven 3.7.3

azure-cosmos-cassandra-driver-3 Maven 1.0.3

azure-cosmos-cassandra-driver-3 Maven 0.14.0

azure-cosmos-cassandra-driver-3-extensions Maven 1.0.3

azure-cosmos-cassandra-driver-4 Maven 1.1.2

azure-cosmos-cassandra-driver-4-extensions Maven 1.1.2

azure-cosmos-spark_3-0_2-12 Maven 4.0.0-beta.1

azure-functions-java-core-library Maven 1.3.0

azure-functions-java-library-sql Maven 2.1.0-preview

Name Package Docs Source

azure-functions-java-spi Maven 1.1.0

azure-toolkit-compute-lib Maven 0.53.0

azure-toolkit-containerapps-lib Maven 0.53.0

azure-toolkit-cosmos-lib Maven 0.53.0

azure-toolkit-database-lib Maven 0.53.0

azure-toolkit-libs Maven 0.53.0

azure-toolkit-monitor-lib Maven 0.53.0

azure-toolkit-postgre-lib Maven 0.53.0

azure-toolkit-resource-lib Maven 0.19.2

azure-toolkit-sqlserver-lib Maven 0.53.0

Bill of Materials Maven 1.0.0.M1

Bill of Materials Maven 2.3.0

Cosmos DB - Cassandra Extensions Maven 0.14.0

Cosmos DB - Cassandra Extensions Parent Maven 0.13.0

Cosmos DB - Cassandra Spark Helper Maven 1.2.0

Cosmos DB - Cassandra Uploader Maven 1.0.16

Cosmos DB - Change Feed Maven 1.0.0-beta-2

Cosmos DB - Change Feed Processor Maven 0.9.2-sources

Cosmos DB - Direct Maven 3.0.0-beta-3

Cosmos DB - Examples Maven 3.3.1

Cosmos DB - Gateway Maven 3.0.0-beta-3

Cosmos DB - Serialization Maven 2.9.6

Cosmos DB - Spark Maven 3.7.0

Document DB - Bulk Executor Maven 2.12.5

Document DB - Bulk Import Maven 1.0.2

Document DB - Hadoop Maven 1.2.0

Name Package Docs Source

Document DB - Reactive Extension Maven 0.9.0-rc2

Elastic Database Tools Maven 1.0.0

Event Hubs Library Maven 0.53.0

kusto-log4j-appender Maven 2.0.3

Schema Registry - Kafka Avro Maven 1.1.2

Service Bus - JMS Maven 1.0.2

Service Bus - JMS Connection Factory Maven 0.0.1

Service Fabric Maven 0.1.0

Session Management - Datastore Azure Cache For Maven 1.0.0-beta.1

Redis

Session Management - Tomcat Maven 1.0.0-beta.1

Spark - Archetype Maven 0.1.0

Spark - CDM Connector Maven 0.19.1

Spark - Kusto Connector Maven 2.3.1

Spark - MsSQL Connector Maven 1.0.2

Spark - Streaming Eventhubs Maven 2.1.5

Spark - Streaming Eventhubs Connector Maven 2.1.4

Spark - Streaming Eventhubs Examples Maven 2.1.4

spark-mssql-connector_2.11_2.4 Maven 1.0.2

spark-mssql-connector_2.12 Maven 1.2.0

Maven 1.3.0-BETA

SQLDB Spark Maven 1.0.2

Management Maven 0.8.0

Resource Management - Client Runtime Maven 1.7.14 GitHub 1.7.14

Resource Management - Parent Maven 1.3.2 GitHub 1.3.2

Auth Helper Plugin Maven 0.7.0

azure-appservice-maven-plugin-lib Maven 1.42.0

Name Package Docs Source

azure-autorest-customization Maven 1.0.0-beta.10

azure-autorest-extension Maven 1.0.0-beta.5

azure-autorest-parent Maven 1.0.0-beta.5

azure-maven-plugins Maven 1.42.0

azure-toolkit-appservice-lib Maven 0.53.0

azure-toolkit-auth-lib Maven 0.53.0

azure-toolkit-cognitiveservices-lib Maven 0.53.0

azure-toolkit-common-lib Maven 0.53.0

azure-toolkit-containerregistry-lib Maven 0.53.0

azure-toolkit-containerservice-lib Maven 0.53.0

azure-toolkit-mysql-lib Maven 0.53.0

azure-toolkit-mysql-single-lib Maven 0.53.0

azure-toolkit-redis-lib Maven 0.53.0

azure-toolkit-springcloud-lib Maven 0.53.0

azure-toolkit-storage-lib Maven 0.53.0

Bundler Maven Plugin Maven 0.0.5

codesnippet-maven-plugin Maven 1.0.0-beta.10

Functions - Maven Plugin Maven 1.38.0

Maven - Plugin Maven 0.2.0

Maven - Plugin Common Maven 0.2.0

Maven - Plugin Lib Maven 0.1.1

Maven - Plugin Library Maven 1.42.0

Maven - Plugins Pom Maven 1.1.0

onnx-protobuf_2.12 Maven 0.9.22

Session Management Maven 1.0.0-beta.1

Session Management - Project Maven 1.0.0-beta.1

Name Package Docs Source

Tools common Maven 0.14.0

Tracing Util Maven 0.9.8

Troposphere Maven Plugin Maven 2.6.0.1

Webapp Maven Plugin Maven 2.14.1

Webapp Maven Plugin Maven 0.1.1

Reference

Services

Active Directory Container Service Fleet Hardware Security Module

Advisor Content Delivery Network HDInsight
API Center Cosmos DB Health Bot
API Management Cosmos DB for PostgreSQL Health Data AI Services
App Compliance Automation Cost Management Health Deidentification
App Configuration Custom Image Search Healthcare APIs
App Service Data Box Hybrid Compute
Application Insights Data Box Edge Hybrid Connectivity
Arc Data Data Explorer Hybrid Kubernetes
Arize AI Data Factory Hybrid Network
Attestation Data Lake Analytics Identity
Authorization Data Lake Store Image Builder
Automanage Data Protection Informatica Data
Automation Database Migration Service Management
Azure Stack Databricks IoT
Azure VMware Solution Datadog Key Vault
BareMetal Infrastructure Desktop Virtualization Kubernetes Configuration
Batch Dev Center Lab Services
Billing DevOps Infrastructure Lambdatesthyperexecute
Bot Service DevTest Labs Load Testing
Change Analysis DNS Log Analytics
Chaos DNS Resolver Logic Apps
Cognitive Services Dynatrace Machine Learning
Communication Edge Order Maintenance
Compute Elastic Managed Applications
Compute Fleet Elastic SAN Managed Network Fabric
Compute Schedule Event Grid Managed Service Identity
Confidential Ledger Event Hubs Maps
Confluent Extended Location MariaDB
Connected VMware Fabric Marketplace Ordering
Consumption Fluid Relay Media Services
Container Apps Front Door Metrics Advisor
Container Instances Functions Mixed Reality
Container Registry Grafana Mobile Network
Container Service Graph Services Mongo Cluster
Mongodbatlas Purestorageblock Service Linker
Monitor Purview Service Networking
MySQL Qumulo SignalR
Neon Postgres Quota Sphere
NetApp Files Recovery Services SQL
Network Redis Standby Pool
New Relic Observability Reservations Storage
Nginx Resource Connector Stream Analytics
Notification Hubs Resource Graph Subscriptions
Operator Nexus - Network Resource Health Support
Cloud Resource Mover Synapse
Oracle Database Resources System Center Virtual
Orbital Schema Registry Machine Manager
Palo Alto Networks Search Tables
Peering Security Traffic Manager
Playwright Testing Security Insights Visual Search
Policy Insights Self Help Web PubSub
PostgreSQL Service Bus Workloads
Power BI Dedicated Service Fabric Other
Private DNS Service Fabric Managed
Provider Hub Clusters