Contents

Azure SDK for Java documentation

Getting started
Get started with Apache Maven
Eclipse and IntelliJ integration
Azure development using Java
Libraries, drivers, and Spring modules
Concepts
Overview
Common concepts
HTTP clients and pipeline
Asynchronous programming
Pagination and iteration
Long-running operations
Proxying
Tracing
Identity and authentication
Overview
Auth in development environments
Auth in Azure hosted applications
Auth with service principals
Auth with user credentials
Logging
Overview
java.util.logging
Logback
Log4J
Integrations
IntelliJ
Eclipse
 Spring
MicroProfile
Troubleshooting
Network issues
Dependency conflicts
Code samples
Virtual machines
Web apps
SQL Database
Security
Containers
All Java samples
Package index
Reference
 Get started with Azure SDK and Apache Maven
2/16/2022 • 4 minutes to read • Edit Online

This article shows you how to use Apache Maven to build applications with the Azure SDK for Java. In this
article, you'll 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 Azure SDK for Java
dependencies 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 will give 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:

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

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

NAME DESC RIP T IO N

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.
 NAME DESC RIP T IO N

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:
-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 will select the latest LTS release, which currently sets a Java 17 baseline. However, you can
override the default behavior by setting the javaVersion parameter.

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 BOM version
number you want to target. Replace the {artifactId} placeholder with the Azure service SDK package name.

<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.
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:

<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 the above 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. That's why we recommended that you rely on
versions that are in Azure SDK BOM unless strictly necessary.

Next steps
Get started with Azure extensions for IntelliJ and Eclipse
 Get started with Azure extensions for IntelliJ and
Eclipse
2/16/2022 • 2 minutes to read • Edit Online

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
 Get started with cloud development using Java on
Azure
2/16/2022 • 7 minutes to read • Edit Online

This article walks you through setting up a development environment for Azure development in Java. You'll then
create some Azure resources and connect to them to do some basic tasks, like uploading a file or deploying a
web application. When you're finished, you'll be ready to start using Azure services in your own Java
applications.

Prerequisites
An Azure account. If you don't have one, get a free trial.
Azure Cloud Shell or Azure CLI 2.0.
Java 8, which is included in Azure Cloud Shell.
Maven 3, which is included in Azure Cloud Shell.

Set up authentication
Your Java application needs read and create permissions in your Azure subscription to run the sample code in
this tutorial. Create a service principal, and configure your application to run with its credentials. Service
principals provide a way to create a noninteractive account associated with your identity to which you grant only
the privileges your app needs to run.
Create a service principal by using the Azure CLI 2.0, and capture the output:

az ad sp create-for-rbac --name AzureJavaTest --role Contributor

This command gives you a reply in the following format:

{
"appId": "a487e0c1-82af-47d9-9a0b-af184eb87646d",
"displayName": "AzureJavaTest",
"name": "http://AzureJavaTest",
"password": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
"tenant": "tttttttt-tttt-tttt-tttt-tttttttttttt"
}

Next, configure the environment variables:

AZURE_SUBSCRIPTION_ID : Use the id value from az account show in the Azure CLI 2.0.
AZURE_CLIENT_ID : Use the appId value from the output taken from a service principal output.
AZURE_CLIENT_SECRET : Use the password value from the service principal output.
AZURE_TENANT_ID : Use the tenant value from the service principal output.

For more authentication options, see the Azure Identity client library for Java.

Tooling
Create a new Maven project
 NOTE
This article uses the Maven build tool to build and run the sample code. Other build tools, such as Gradle, also work with
the Azure SDK for Java.

Create a Maven project from the command line in a new directory on your system.

mkdir java-azure-test
cd java-azure-test
mvn archetype:generate -DgroupId=com.fabrikam -DartifactId=AzureApp \
-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

This step creates a basic Maven project under the testAzureApp directory. Add the following entries into the
project's pom.xml file to import the libraries used in the sample code in this tutorial.

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>com.azure.resourcemanager</groupId>
<artifactId>azure-resourcemanager</artifactId>
<version>2.6.0</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-storage-blob</artifactId>
<version>12.8.0</version>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>6.2.1.jre8</version>
</dependency>

Add a build entry under the top-level project element to use the maven-exec-plugin to run the samples.

<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.0.0</version>
<configuration>
<mainClass>com.fabrikam.AzureApp</mainClass>
</configuration>
</plugin>
</plugins>
</build>

Create a Linux virtual machine

Create a new file named AzureApp.java in the project's src/main/java/com/fabrikam directory, and paste in the
following block of code. Update the userName and sshKey variables with real values for your machine. The code
creates a new Linux virtual machine (VM) with the name testLinuxVM in the resource group
sampleResourceGroup running in the US East Azure region.
 package com.fabrikam;

import com.azure.core.credential.TokenCredential;
import com.azure.core.http.policy.HttpLogDetailLevel;
import com.azure.core.management.AzureEnvironment;
import com.azure.core.management.Region;
import com.azure.core.management.profile.AzureProfile;
import com.azure.identity.AzureAuthorityHosts;
import com.azure.identity.EnvironmentCredentialBuilder;
import com.azure.resourcemanager.AzureResourceManager;
import com.azure.resourcemanager.compute.models.KnownLinuxVirtualMachineImage;
import com.azure.resourcemanager.compute.models.VirtualMachine;
import com.azure.resourcemanager.compute.models.VirtualMachineSizeTypes;

public class AzureApp {

public static void main(String[] args) {

final String userName = "YOUR_VM_USERNAME";

final String sshKey = "YOUR_PUBLIC_SSH_KEY";

try {
TokenCredential credential = new EnvironmentCredentialBuilder()
.authorityHost(AzureAuthorityHosts.AZURE_PUBLIC_CLOUD)
.build();

// If you don't set the tenant ID and subscription ID via environment variables,
// change to create the Azure profile with tenantId, subscriptionId, and Azure environment.
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager azureResourceManager = AzureResourceManager.configure()

.withLogLevel(HttpLogDetailLevel.BASIC)
.authenticate(credential, profile)
.withDefaultSubscription();

// Create an Ubuntu virtual machine in a new resource group.

VirtualMachine linuxVM = azureResourceManager.virtualMachines().define("testLinuxVM")
.withRegion(Region.US_EAST)
.withNewResourceGroup("sampleVmResourceGroup")
.withNewPrimaryNetwork("10.0.0.0/24")
.withPrimaryPrivateIPAddressDynamic()
.withoutPrimaryPublicIPAddress()
.withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
.withRootUsername(userName)
.withSsh(sshKey)
.withUnmanagedDisks()
.withSize(VirtualMachineSizeTypes.STANDARD_D3_V2)
.create();

} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}

Run the sample from the command line.

mvn compile exec:java

You'll see some REST requests and responses in the console as the SDK makes the underlying calls to the Azure
REST API to configure the VM and its resources. After the program finishes, verify the VM in your subscription
with the Azure CLI 2.0.
 az vm list --resource-group sampleVmResourceGroup

After you've verified that the code worked, use the CLI to delete the VM and its resources.

az group delete --name sampleVmResourceGroup

Deploy a web app from a GitHub repo

Replace the main method in AzureApp.java with the following one. Update the appName variable to a unique
value before you run the code. This code deploys a web application from the master branch in a public GitHub
repo into a new Azure App Service Web App running in the free pricing tier.

public static void main(String[] args) {

try {

final String appName = "YOUR_APP_NAME";

TokenCredential credential = new EnvironmentCredentialBuilder()

.authorityHost(AzureAuthorityHosts.AZURE_PUBLIC_CLOUD)
.build();

// If you don't set the tenant ID and subscription ID via environment variables,
// change to create the Azure profile with tenantId, subscriptionId, and Azure environment.
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager azureResourceManager = AzureResourceManager.configure()

.withLogLevel(HttpLogDetailLevel.BASIC)
.authenticate(credential, profile)
.withDefaultSubscription();

WebApp app = azureResourceManager.webApps().define(appName)

.withRegion(Region.US_WEST2)
.withNewResourceGroup("sampleWebResourceGroup")
.withNewWindowsPlan(PricingTier.FREE_F1)
.defineSourceControl()
.withPublicGitRepository(
"https://github.com/Azure-Samples/app-service-web-java-get-started")
.withBranch("master")
.attach()
.create();

} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}

Run the code as before using Maven.

mvn clean compile exec:java

Open a browser pointed to the application by using the CLI.

az webapp browse --resource-group sampleWebResourceGroup --name YOUR_APP_NAME

Remove the web app and plan from your subscription after you've verified the deployment.
 az group delete --name sampleWebResourceGroup

Connect to an Azure SQL database

Replace the current main method in AzureApp.java with the following code. Set real values for the variables.
This code creates a new SQL database with a firewall rule that allows remote access. Then the code connects to it
by using the SQL Database JBDC driver.

public static void main(String args[])

{
// Create the db using the management libraries.
try {
TokenCredential credential = new EnvironmentCredentialBuilder()
.authorityHost(AzureAuthorityHosts.AZURE_PUBLIC_CLOUD)
.build();

// If you don't set the tenant ID and subscription ID via environment variables,
// change to create the Azure profile with tenantId, subscriptionId, and Azure environment.
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager azureResourceManager = AzureResourceManager.configure()

.withLogLevel(HttpLogDetailLevel.BASIC)
.authenticate(credential, profile)
.withDefaultSubscription();

final String adminUser = "YOUR_USERNAME_HERE";

final String sqlServerName = "YOUR_SERVER_NAME_HERE";
final String sqlDbName = "YOUR_DB_NAME_HERE";
final String dbPassword = "YOUR_PASSWORD_HERE";
final String firewallRuleName = "YOUR_RULE_NAME_HERE";

SqlServer sampleSQLServer = azureResourceManager.sqlServers().define(sqlServerName)

.withRegion(Region.US_EAST)
.withNewResourceGroup("sampleSqlResourceGroup")
.withAdministratorLogin(adminUser)
.withAdministratorPassword(dbPassword)
.defineFirewallRule(firewallRuleName)
.withIpAddressRange("0.0.0.0","255.255.255.255")
.attach()
.create();

SqlDatabase sampleSQLDb = sampleSQLServer.databases().define(sqlDbName).create();

// Assemble the connection string to the database.

final String domain = sampleSQLServer.fullyQualifiedDomainName();
String url = "jdbc:sqlserver://"+ domain + ":1433;" +
"database=" + sqlDbName +";" +
"user=" + adminUser+ "@" + sqlServerName + ";" +
"password=" + dbPassword + ";" +

"encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;";

// Connect to the database, create a table, and insert an entry into it.
Connection conn = DriverManager.getConnection(url);

String createTable = "CREATE TABLE CLOUD ( name varchar(255), code int);";

String insertValues = "INSERT INTO CLOUD (name, code ) VALUES ('Azure', 1);";
String selectValues = "SELECT * FROM CLOUD";
Statement createStatement = conn.createStatement();
createStatement.execute(createTable);
Statement insertStatement = conn.createStatement();
insertStatement.execute(insertValues);
Statement selectStatement = conn.createStatement();
ResultSet rst = selectStatement.executeQuery(selectValues);
 while (rst.next()) {
System.out.println(rst.getString(1) + " "
+ rst.getString(2));
}

} catch (Exception e) {
System.out.println(e.getMessage());
System.out.println(e.getStackTrace().toString());
}
}

Run the sample from the command line.

mvn clean compile exec:java

Then clean up the resources by using the CLI.

az group delete --name sampleSqlResourceGroup

Write a blob into a new storage account

Replace the current main method in AzureApp.java with the following code. This code creates an Azure storage
account. Then the code uses the Azure Storage libraries for Java to create a new text file in the cloud.
 public static void main(String[] args) {

try {
TokenCredential tokenCredential = new EnvironmentCredentialBuilder()
.authorityHost(AzureAuthorityHosts.AZURE_PUBLIC_CLOUD)
.build();

// If you don't set the tenant ID and subscription ID via environment variables,
// change to create the Azure profile with tenantId, subscriptionId, and Azure environment.
AzureProfile profile = new AzureProfile(AzureEnvironment.AZURE);

AzureResourceManager azureResourceManager = AzureResourceManager.configure()

.withLogLevel(HttpLogDetailLevel.BASIC)
.authenticate(tokenCredential, profile)
.withDefaultSubscription();

// Create a new storage account.

String storageAccountName = "YOUR_STORAGE_ACCOUNT_NAME_HERE";
StorageAccount storage = azureResourceManager.storageAccounts().define(storageAccountName)
.withRegion(Region.US_WEST2)
.withNewResourceGroup("sampleStorageResourceGroup")
.create();

// Create a storage container to hold the file.

List<StorageAccountKey> keys = storage.getKeys();
PublicEndpoints endpoints = storage.endPoints();
String accountName = storage.name();
String accountKey = keys.get(0).value();
String endpoint = endpoints.primary().blob();

StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);

BlobServiceClient storageClient =new BlobServiceClientBuilder()

.endpoint(endpoint)
.credential(credential)
.buildClient();

// Container name must be lowercase.

BlobContainerClient blobContainerClient = storageClient.getBlobContainerClient("helloazure");
blobContainerClient.create();

// Make the container public.

blobContainerClient.setAccessPolicy(PublicAccessType.CONTAINER, null);

// Write a blob to the container.

String fileName = "helloazure.txt";
String textNew = "Hello Azure";

BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

InputStream is = new ByteArrayInputStream(textNew.getBytes());
blobClient.upload(is, textNew.length());

} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}

Run the sample from the command line.

mvn clean compile exec:java

You can browse for the helloazure.txt file in your storage account through the Azure portal or with Azure
Storage Explorer.
Clean up the storage account by using the CLI.

az group delete --name sampleStorageResourceGroup

Explore more samples

To learn more about how to use the Azure management libraries for Java to manage resources and automate
tasks, see our sample code for virtual machines, web apps, and SQL database.

Reference and release notes

A reference is available for all packages.

Get help and give feedback

Post questions to the community on Stack Overflow. Report bugs and open issues against the Azure SDK for
Java in the GitHub repository.
 Java libraries, drivers, and Spring modules for Azure
2/16/2022 • 3 minutes to read • Edit Online

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.

JAVA L IB RA RY JAVA GET T IN G SP RIN G GET T IN G

C AT EGO RY A Z URE SERVIC E O R DRIVER STA RT ED SP RIN G M O DUL E STA RT ED

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

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

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

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

Data Cosmos DB - Maven Quickstart: Build Spring Data How to use the
SQL Repository: a Java app to Cosmos DB Spring Boot
com.azure » manage Azure Starter with the
azure-cosmos Cosmos DB SQL Azure Cosmos
API data DB SQL API
 JAVA L IB RA RY JAVA GET T IN G SP RIN G GET T IN G
C AT EGO RY A Z URE SERVIC E O R DRIVER STA RT ED SP RIN G M O DUL E STA RT ED

Data Cosmos DB - MongoDB Java Quickstart: Spring Data How to use

MongoDB Drivers Create a console MongoDB Spring Data
app with Java MongoDB API
and the with Azure
MongoDB API in Cosmos DB
Azure Cosmos
DB

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

Data Cosmos DB - Gremlin Java Quickstart: Build Quickstart: Build

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

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

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

Cache Redis LETTUCE client Best Practices for • Spring Data Configure a
using Azure Redis Spring Boot
Cache for Redis • Reference Initializer app to
with Lettuce use Redis in the
cloud with Azure
Redis Cache

Storage Azure Storage Maven Quickstart: How to use the

Repository: Manage blobs Spring Boot
com.azure » with Java v12 Starter for Azure
azure-storage- SDK Storage
blob

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

Messaging Service Bus Azure Service Azure Service Spring AMQP How to use
Bus client library Bus Samples Spring Cloud
for Java client library for Azure Stream
Java Binder for Azure
Service Bus
 JAVA L IB RA RY JAVA GET T IN G SP RIN G GET T IN G
C AT EGO RY A Z URE SERVIC E O R DRIVER STA RT ED SP RIN G M O DUL E STA RT ED

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

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

Directory Azure Active MSAL Enable Java Azure AD Spring Enable Spring
Directory Servlet apps to Boot Starter Boot Web apps
sign in users on to sign in users
Azure AD on Azure AD

Directory Azure Active MSAL Enable Java Azure AD B2C Enable Spring
Directory B2C Servlet apps to Spring Boot Boot Web apps
sign in users on Starter to sign in users
Azure AD B2C on Azure AD
B2C

Secrets Key Vault Key Vault Secrets Manage secrets Key Vault Secrets Manage secrets
using Key Vault Spring Boot for Spring 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
2/16/2022 • 5 minutes to read • Edit Online

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 :

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 :

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 :

ComputeManager computeManager = ComputeManager

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

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

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:

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:

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
 HTTP clients and pipelines in the Azure SDK for
Java
2/16/2022 • 5 minutes to read • Edit Online

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
The new HttpClient introduced in JDK 11
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:

<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 will fail to start. An
HttpClient implementation must exist on the classpath.

Configure HTTP clients

When you build a service client, it will default 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.

// 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.

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.

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 will create 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 will act 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 will log the request and response but the authentication policy
is only interested in modifying the request.
The Azure Core framework will provide 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 pre-loaded with these commonly required
HTTP policies that you can add to the pipeline.

P O L IC Y GIT H UB L IN K

Retry Policy RetryPolicy.java

Authentication Policy BearerTokenAuthenticationPolicy.java

Logging Policy HttpLoggingPolicy.java

 P O L IC Y GIT H UB L IN K

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 are either created by the user or by the client library developer.
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.

Next steps
Now that you're familiar with HTTP client functionality in the Azure SDK for Java, see Configure proxies in the
Azure SDK for Java to learn how to further customize the HTTP client you're using.
 Asynchronous programming in the Azure SDK for
Java
2/16/2022 • 10 minutes to read • Edit Online

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:

API TYPE N O VA L UE SIN GL E VA L UE M ULT IP L E VA L UES

Standard Java - void T Iterable<T>

Synchronous APIs

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

Asynchronous APIs

Reactive Streams Interfaces Publisher<Void> Publisher<T> Publisher<T>

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.

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.

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:

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:
 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 :

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.
 Pagination and iteration in the Azure SDK for Java
2/16/2022 • 4 minutes to read • Edit Online

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:

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:
 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:

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:

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.

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.

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.

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.
 Long-running operations in the Azure SDK for Java
2/16/2022 • 4 minutes to read • Edit Online

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 .

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:

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() :

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:

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:
 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.
 Configure proxies in the Azure SDK for Java
2/16/2022 • 3 minutes to read • Edit Online

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 instance by calling
ProxyOptions
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.)

export HTTP_PROXY=localhost:8888

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:

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.

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 ):
 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:

// 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:

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.
 Configure tracing in the Azure SDK for Java
2/16/2022 • 2 minutes to read • Edit Online

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 of SDK (preview)

To enable Azure SDK tracing, add the latest com.azure:azure-core-tracing-opentelemetry packages to your
application. For more information, see Azure OpenTelemetry Tracing plugin library for Java. For example, in
Maven, add the following entry to your pom.xml file, replacing the {latest version} placeholder with the
correct version number:

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-core-tracing-opentelemetry</artifactId>
<version>{latest version}</version>
</dependency>

If you use an OpenTelemetry agent, that's all you have to do to start getting spans from Azure SDKs. For more
details on how to configure exporters, add manual instrumentation, or enrich telemetry, see OpenTelemetry
Instrumentation for Java.
Manually instrument the application with OpenTelemetry SDK
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.
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.

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.
 Azure authentication with Java and Azure Identity
2/16/2022 • 4 minutes to read • Edit Online

This article provides an overview of the Java Azure Identity library, which provides Azure Active Directory 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 AAD token authentication.
The Azure Identity library currently supports:
Azure authentication in Java development environments, which enables:
IDEA IntelliJ authentication, with the login information retrieved from the Azure Toolkit for IntelliJ.
Visual Studio Code authentication, with the login information saved in Azure plugin for Visual Studio
Code.
Azure CLI authentication, with the login information saved in the Azure CLI
Authenticating applications hosted in Azure, which enables:
Default Azure Credential 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 the links above to learn more about the specifics of each of these authentication approaches. In the rest
of this article, we'll introduce the commonly used DefaultAzureCredential and related topics.

Add the Maven dependencies

To add the Maven dependency, include the following XML in the project's pom.xml file. Replace the 1.2.1 version
number with the latest released version number shown on the Microsoft Azure Client Library For Identity page.

<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity</artifactId>
<version>1.2.1</version>
</dependency>

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, the 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 Azure Active Directory, and it offers various
credential classes that can acquire an AAD 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 .
The 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 Default Azure credential 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 below demonstrates authenticating the SecretClient from the azure-security-keyvault-
secrets client library using the DefaultAzureCredential .

// 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:

az account list --output table

You can set the subscription ID in the AZURE_SUBSCRIPTION_ID environment variable. This ID is picked up by
AzureProfile as the default subscription ID during the creation of a Manager instance, as shown in the
following example:

AzureResourceManager azureResourceManager = AzureResourceManager.authenticate(

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

The DefaultAzureCredential used in this example authenticates an AzureResourceManager instance using the
DefaultAzureCredential . You can also use other Token Credential implementations offered in the Azure Identity
library in place of DefaultAzureCredential .

Troubleshooting
Credentials raise exceptions either when they fail to authenticate or can't execute authentication. When
credentials fail to authenticate, the ClientAuthenticationException is raised and it has a message attribute that
describes why authentication failed. When ChainedTokenCredential raises this exception, the chained execution
of underlying list of credentials is stopped.
When credentials can't execute authentication because one of the underlying resources required by the
credential is unavailable on the machine, the CredentialUnavailableException is raised and it has a message
attribute that describes why the credential is unavailable for authentication execution. When
ChainedTokenCredential raises this exception, the message collects error messages from each credential in the
chain.

Next steps
This article introduced the Azure Identity functionality available in the Azure SDK for Java. It described the
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 the
DefaultAzureCredential :

Azure authentication in development environments

Authenticating applications hosted in Azure
Authentication with service principals
Authentication with user credentials
 Azure authentication in Java development
environments
2/16/2022 • 6 minutes to read • Edit Online

This article provides an overview of the Azure Identity library support for Azure Active Directory token
authentication. This support enables authentication for applications running locally on developer machines
through a set of TokenCredential implementations.
Topics covered in this article include:
Device code credential
Interactive browser credential
Azure CLI credential
IntelliJ credential
Visual Studio Code 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 login 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 login 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 Azure Active Directory 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 will let the application authenticate, but it still won't have permission to log you into Active
Directory, 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 log in for the first
time.
If you can't configure the device code flow option on your Active Directory, 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 director y . 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.
 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 Azure Active Directory with
permissions to log in on behalf of a user. Follow the steps above 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 log 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 AAD 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 .

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 logged into it, and uses the CLI to authenticate the
application against Azure Active Directory.
Sign in Azure CLI for AzureCliCredential
Sign in as a user with the following Azure CLI command:

az login

Sign in as a service principal using the following command:

 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:

az account list

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

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
will prompt 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.

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 logged in user information on the IntelliJ IDE and uses it to authenticate the application against Azure
Active Directory.

Sign in Azure Toolkit for IntelliJ for IntelliJCredential

Follow the steps outlined below:
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 will help you log in as a user account. Follow the instructions to log in on the
login.microsoftonline.com website with the device code. IntelliJ will prompt you to select your subscriptions.
Select the subscription with the resources that you want to access.
On Windows, you'll also need the KeePass database path to read IntelliJ credentials. You can find the path in
IntelliJ settings under File > Settings > Appearance & Behavior > System Settings > Passwords . Note
down the location of the KeePassDatabase path.

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.

IntelliJCredential intelliJCredential = new IntelliJCredentialBuilder()

// KeePass configuration isrequired only for Windows. No configuration needed for Linux / Mac.
.keePassDatabasePath("C:\\Users\\user\\AppData\\Roaming\\JetBrains\\IdeaIC2020.1\\c.kdbx")
.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();

Visual Studio Code credential

The Visual Studio Code credential enables authentication in development environments where VS Code is
installed with the VS Code Azure Account extension. It uses the logged-in user information in the VS Code IDE
and uses it to authenticate the application against Azure Active Directory.
Sign in Visual Studio Code Azure Account Extension for VisualStudioCodeCredential
The Visual Studio Code authentication is handled by an integration with the Azure Account extension. To use this
form of authentication, install the Azure Account extension, then use View > Command 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. After you've completed the login process, you can close the browser as directed. Running your
application (either in the debugger or anywhere on the development machine) will use the credential from your
sign-in.
Authenticate a user account with Visual Studio Code
The following example demonstrates authenticating the SecretClient from the azure-security-keyvault-secrets
client library using the VisualStudioCodeCredential on a workstation where Visual Studio Code is installed, and
the user has signed in with an Azure account.

VisualStudioCodeCredential visualStudioCodeCredential = new VisualStudioCodeCredentialBuilder().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(visualStudioCodeCredential)
.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
After you've mastered authentication, see Configure logging in the Azure SDK for Java for information on the
logging functionality provided by the SDK.
 Authenticate Azure-hosted Java applications
2/16/2022 • 4 minutes to read • Edit Online

This article looks at how the Azure Identity library supports Azure Active Directory token authentication for
applications hosted on Azure. This support is made possible through a set of TokenCredential implementations,
which are discussed below.
This article covers the following topics:
Default Azure credential
Managed Identity credential

Default Azure credential

The DefaultAzureCredential is appropriate for most scenarios where the application ultimately runs 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. The DefaultAzureCredential will
attempt to authenticate via the following mechanisms in order.

Environment - The DefaultAzureCredential will read account information specified via environment variables
and use it to authenticate.
Managed Identity - If the application deploys to an Azure host with Managed Identity enabled, the
DefaultAzureCredential will authenticate with that account.
IntelliJ - If you've authenticated via Azure Toolkit for IntelliJ, the DefaultAzureCredential will authenticate with
that account.
Visual Studio Code - If you've authenticated via the Visual Studio Code Azure Account plugin, the
DefaultAzureCredential will authenticate with that account.
Azure CLI - If you've authenticated an account via the Azure CLI az login command, the
DefaultAzureCredential will authenticate with that account.

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 the 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 the DefaultAzureCredential to authenticate as a user-defined 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 the
DefaultAzureCredential to authenticate to a specific tenant for shared token cache, Visual Studio Code, and
IntelliJ IDEA.
Setting the environment variable AZURE_USERNAME configures the DefaultAzureCredential to pick the
corresponding cached token from the shared token cache.
Setting .intelliJKeePassDatabasePath(String) on the builder configures the DefaultAzureCredential to read
a specific KeePass file when authenticating with IntelliJ credentials.
Authenticate with DefaultAzureCredential
The following example demonstrates authenticating the SecretClient from the azure-security-keyvault-secrets
client library using the DefaultAzureCredential .

// 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 a user assigned managed identity with DefaultAzureCredential

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

/**
* The default credential will use the user-assigned managed identity with the specified client ID.
*/
DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
.managedIdentityClientId("<managed identity client 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(defaultCredential)
.buildClient();

Authenticate a user in Azure Toolkit for IntelliJ with DefaultAzureCredential

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

/**
* The default credential will use the KeePass database path to find the user account in IntelliJ on
Windows.
*/
// KeePass configuration is required only for Windows. No configuration needed for Linux / Mac.
DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder()
.intelliJKeePassDatabasePath("C:\\Users\\user\\AppData\\Roaming\\JetBrains\\IdeaIC2020.1\\c.kdbx")
.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(defaultCredential)
.buildClient();

Managed Identity credential

The Managed Identity authenticates the managed identity (system 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 will get your application authenticated, and offers a great
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, function app, Cloud Shell,
service fabric, arc, or AKS environment on Azure, with system-assigned or user-assigned managed identity
enabled.

/**
* Authenticate with a managed identity.
*/
ManagedIdentityCredential managedIdentityCredential = new ManagedIdentityCredentialBuilder()
.clientId("<user-assigned managed identity client ID>") // required only for user-assigned
.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(managedIdentityCredential)
.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
VA RIA B L E N A M E VA L UE

AZURE_CLIENT_ID ID of an Azure Active Directory application.

AZURE_TENANT_ID ID of the application's Azure Active Directory tenant.

AZURE_CLIENT_SECRET One of the application's client secrets.

Service principal with certificate

VA RIA B L E N A M E VA L UE

AZURE_CLIENT_ID ID of an Azure Active Directory application.

AZURE_TENANT_ID ID of the application's Azure Active Directory tenant.

AZURE_CLIENT_CERTIFICATE_PATH Path to a PEM-encoded certificate file including private key

(without password protection).

Username and password

VA RIA B L E N A M E VA L UE

AZURE_CLIENT_ID ID of an Azure Active Directory application.

AZURE_USERNAME A username (usually an email address).

 VA RIA B L E N A M E VA L UE

AZURE_PASSWORD The associated password for the given username.

Configuration is attempted in the above 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
After you've mastered authentication, see Configure logging in the Azure SDK for Java for information on the
logging functionality provided by the SDK.
 Azure authentication with service principal
2/16/2022 • 2 minutes to read • Edit Online

This article looks at how the Azure Identity library supports Azure Active Directory token authentication via
service principal. Topics covered in this article include:
Create a service principal with the Azure CLI
Client secret credential
Client certificate credential
For more information, see Application and service principal objects in Azure Active Directory.

Create a service principal with the Azure CLI

Use the Azure CLI examples below to create or get client secret credentials.
Use the following command to create a service principal and configure its access to Azure resources:

az ad sp create-for-rbac -n <your application name> --role Contributor

This command returns a value similar to the following 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.

az ad sp create-for-rbac -n <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 .
 /**
* 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 .

/**
* 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>", "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
After you've mastered authentication, see Configure logging in the Azure SDK for Java for information on the
logging functionality provided by the SDK.
 Azure authentication with user credentials
2/16/2022 • 3 minutes to read • Edit Online

This article looks at how the Azure Identity library supports Azure Active Directory token authentication with
user-provided credentials. This support is made possible through a set of TokenCredential implementations
discussed below.
This article covers the following topics:
Device code credential
Interactive browser credential
Username password 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 login 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 login 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 Azure Active Directory 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 will let the application authenticate, but it still won't have permission to log you into Active
Directory, 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 Azure Service Management, Key Vault, and so
on.
You also need to be the admin of your tenant to grant consent to your application when you log in for the first
time.
If you can't configure the device code flow option on your Active Directory, 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 director y . 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.
 /**
* 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 you own credentials to authenticate your application.
Enable applications for interactive browser OAuth 2 flow
To use InteractiveBrowserCredential , you need to register an application in Azure Active Directory with
permissions to log in on behalf of a user. Follow the steps above 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 log 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 AAD 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 .

/**
* 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();

Username password credential

The UsernamePasswordCredential helps to authenticate a public client application using the user credentials that
don't require multi-factor authentication. The following example demonstrates authenticating the SecretClient
from the azure-security-keyvault-secrets client library using the UsernamePasswordCredential . The user must not
have multi-factor auth turned on.
 /**
* Authenticate with username, password.
*/
UsernamePasswordCredential usernamePasswordCredential = new UsernamePasswordCredentialBuilder()
.clientId("<your app client ID>")
.username("<your username>")
.password("<your password>")
.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(usernamePasswordCredential)
.buildClient();

For more information, see Microsoft identity platform and OAuth 2.0 Resource Owner Password Credentials.

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.
 Configure logging in the Azure SDK for Java
2/16/2022 • 2 minutes to read • Edit Online

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.

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 has been 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 will take precedence), and then set the
AZURE_LOG_LEVEL environment variable. The following table shows the values allowed for this environment
variable:

LO G L EVEL A L LO W ED EN VIRO N M EN T VA RIA B L E VA L UES

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 will log 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 do not log, and so on. Some examples
are provided through the links below, but for more detail, see the documentation for your chosen logging
framework.

Next steps
Now that you've seen how logging works in the Azure SDK for Java, consider reviewing the links below for
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
 Log with the Azure SDK for Java and
java.util.logging
2/16/2022 • 2 minutes to read • Edit Online

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 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.

<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 ./src/main/resources directory of
your project. This file will contain the logging configurations to customize your logging needs. For more
information, see Java Logging: Configuration.
If you would like to use a different filename other than logging.properties, you can do so by setting the
java.util.logging.config.file system property. This property must be set before the logger instance is created.

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.

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$tT] [%4$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:

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.
 Log with the Azure SDK for Java and Logback
2/16/2022 • 3 minutes to read • Edit Online

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.

<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 will contain 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 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 example configuration below 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
below, com.azure.core will control 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 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 examples above 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 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:
 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.
 Log with the Azure SDK for Java and Log4j
2/16/2022 • 2 minutes to read • Edit Online

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.

<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/resource directory of the project.
This file should take the following form:

appender.console.type = Console
appender.console.name = STDOUT
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %msg%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/resource directory of the project. This file should
take the following form:

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

<Configuration status="INFO">
<Appenders>
<Console name="console" target="SYSTEM_OUT">
<PatternLayout pattern="%msg%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 and MicroProfile.
 Spring Boot Starters for Azure
2/16/2022 • 4 minutes to read • Edit Online

This article describes the various Spring Boot Starters for the Spring Initializr that provide Java developers with
integration features for working with Microsoft Azure.

The following Spring Boot Starters are currently available for Azure:
Azure Suppor t
Provides auto-configuration support for Azure Services; e.g. Service Bus, Storage, Active Directory, etc.
Azure Active Director y
Provides integration support for Spring Security with Azure Active Directory for authentication.
Azure Key Vault
Provides Spring value annotation support for integration with Azure Key Vault Secrets.
Azure Storage
Provides Spring Boot support for Azure Storage services.

NOTE
The new version of the Spring Boot Starter for Azure Storage doesn't currently support adding an Azure storage
dependency from within Spring Initializr. However, you can add the dependency by modifying the pom.xml file
after the project is generated.

Azure Support
This Spring Boot Starter provides auto-configuration support for Azure Services; for example: Service Bus,
Storage, Active Directory, Cosmos DB, Key Vault, etc.
For examples of how to use the various Azure features that are provided by this starter, see the following:
The azure-spring-boot-samples repo on GitHub.
When you add this starter to a Spring Boot project, the following changes are made to the pom.xml file:
The following property is added to <properties> element:

<properties>
<!-- Other properties will be listed here -->
<java.version>1.8</java.version>
<azure.version>3.13.0</azure.version>
</properties>

The default spring-boot-starter dependency is replaced with the following:

<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

The following section is added to the file:

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

Azure Active Directory

This Spring Boot Starter provides auto-configuration support for Spring Security in order to provide integration
with Azure Active Directory for authentication.
For examples of how to use the Azure Active Directory features that are provided by this starter, see the
following:
The azure-spring-boot-samples repo on GitHub.
When you add this starter to a Spring Boot project, the following changes are made to the pom.xml file:
 The following property is added to <properties> element:

<properties>
<!-- Other properties will be listed here -->
<java.version>1.8</java.version>
<azure.version>3.13.0</azure.version>
</properties>

The default spring-boot-starter dependency is replaced with the following:

<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter-active-directory</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

The following section is added to the file:

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

Azure Key Vault

This Spring Boot Starter provides Spring value annotation support for integration with Azure Key Vault Secrets.
For examples of how to use the Azure Key Vault features that are provided by this starter, see the following:
Sample for Azure Key Vault Secrets Spring Boot Starter client library for Java
When you add this starter to a Spring Boot project, the following changes are made to the pom.xml file:
The following property is added to <properties> element:
 <properties>
<!-- Other properties will be listed here -->
<java.version>1.8</java.version>
<azure.version>3.13.0</azure.version>
</properties>

The default spring-boot-starter dependency is replaced with the following:

<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter-keyvault-secrets</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

The following section is added to the file:

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

Azure Storage
This Spring Boot Starter provides Spring Boot integration support for Azure Storage services.
For examples of how to use the Azure Storage features that are provided by this starter, see the following:
How to use the Spring Boot Starter for Azure Storage
Spring Cloud Azure Storage Queue Operation Code Sample shared library for Java
When you add this starter to a Spring Boot project, the following changes are made to the pom.xml file:
The following property is added to <properties> element:
 <properties>
<!-- Other properties will be listed here -->
<java.version>1.8</java.version>
<azure.version>3.13.0</azure.version>
</properties>

The default spring-boot-starter dependency is replaced with the following:

<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter-storage</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

The following section is added to the file:

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

Application Insights
Azure Monitor Application Insights can help you understand how your app is performing and how it's being
used. Application Insights uses the Java agent to enable the application monitor. There are no code changes
needed, and you can enable the Java agent with just a couple of configuration changes. For instructions and
more information, see Java codeless application monitoring Azure Monitor Application Insights.

Next steps
To learn more about Spring and Azure, continue to the Spring on Azure documentation center.
Spring on Azure
Additional Resources
For more information about using Spring Boot applications on Azure, see Spring on Azure.
For more information about using Azure with Java, see the Azure for Java Developers and the Working with
Azure DevOps and Java.
For help with getting started with your own Spring Boot applications, see the Spring Initializr at
https://start.spring.io/.
 Troubleshoot networking issues
2/16/2022 • 5 minutes to read • Edit Online

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 you need 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 procedures describe how to use the Java Runtime Environment (JRE) to trust the certificate.
Without trusting the certificate, an HTTPS request through Fiddler may fail with security warnings.
Linux/macOS
1. Export Fiddler's certificate.
2. Find the JRE's keytool (usually jre/bin ).
3. Find the JRE's cacert (usually jre/lib/security ).
4. Open a Bash window and run the following command to import the certificate:

sudo keytool -import -file <location of Fiddler certificate> -keystore <location of cacert> -alias
Fiddler

5. Enter a password.
6. Trust the certificate.
Windows
1. Export Fiddler's certificate. The certificate is typically exported to the desktop.
2. Find the JRE's keytool (usually jre\bin ).
3. Find the JRE's cacert (usually jre\lib\security ).
4. Open a PowerShell window in administrator mode and run the following command to import the
certificate:

keytool.exe -import -trustcacerts -file <location of Fiddler certificate> -keystore <location of

cacert> -alias Fiddler

For example, the following command uses some common values:

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 have not 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 will capture 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 will capture 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 are 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 capture or 50 MB in size.
In Wireshark, navigate to Capture > Options and find the Output tab, then enter a file name to use. This
configuration will cause 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 will have Wireshark create a new file when one of the predicates is matched. Each new file will use
the same base name as the file name entered, and will append 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 will limit
Wireshark to logging with only the specified number of files. When that number of files is reached, Wireshark
will begin 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 above, 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 above. After the
file has loaded below the menu bar, a filter input will appear. In the filter input, enter ip.src_host==<IP> . This
filter will limit the capture view so that it shows only captures where the source was from the host with the IP
<IP> .

Next steps
This topic 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.
 Troubleshoot dependency version conflicts
2/16/2022 • 7 minutes to read • Edit Online

This article describes dependency version conflicts and how to troubleshoot them.
Azure client libraries for Java depend on several popular third-party libraries: Jackson, Netty, Reactor, and 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 how to diagnose version mismatch issues.
View a dependency tree
Run mvn dependency:tree or gradle dependencies --scan to show the full dependency tree for your application,
with version numbers. (Note that 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 is with Apache Spark 3.0.0
(and later), which depends on Jackson 2.10. While it is 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
isn't supported by the Azure SDK for Java, continue reading this document 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/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 does'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
versions. It's good practice to keep dependencies up to date because it 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, does not 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, renaming packages, and updating
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 is not
supported by Azure SDKs, 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 and 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 details on azure-core -specific dependencies and their versions, see azure-core at the Maven Central
Repository. The following table shows some general considerations:

DEP EN DEN C Y SUP P O RT ED VERSIO N S

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-boringssl-static 2.0.*
 DEP EN DEN C Y SUP P O RT ED VERSIO N S

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

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.
 Azure management libraries for Java - Virtual
machine samples
2/16/2022 • 2 minutes to read • Edit Online

The following table links to Java source you can use to create and configure Azure virtual machines.

SA M P L E DESC RIP T IO N

Create a virtual machine from a custom image Create a custom virtual machine image and use it to create
new virtual machines.

Create a virtual machine using specialized VHD from a Create snapshot from the virtual machine's OS and data
snapshot disks, create managed disks from the snapshots, and then
create a virtual machine by attaching the managed disks.

Create virtual machines in parallel in the same network Create virtual machines in the same region on the same
virtual network with two subnets in parallel.
 Azure management libraries for Java - Web app
samples
2/16/2022 • 2 minutes to read • Edit Online

The following table links to Java source you can use to create and configure web apps.

SA M P L E DESC RIP T IO N

Create an app

Create a web app and deploy from FTP or GitHub Deploy web apps from local Git, FTP, and continuous
integration from GitHub.

Create a web app and manage deployment slots Create a web app and deploy to staging slots, and then
swap deployments between slots.

Configure an app

Create a web app and configure a custom domain Create a web app with a custom domain and self-signed SSL
certificate.

Scale an app

Scale a web app with high availability across multiple regions Scale a web app in three different geographical regions and
make them available through a single endpoint using Azure
Traffic Manager.

Connect an app to resources

Connect a web app to a storage account Create an Azure storage account and add the storage
account connection string to the app settings.

Connect a web app to a SQL database Create a web app and SQL database, and then add the SQL
database connection string to the app settings.
 Azure management libraries for Java - SQL
Database samples
2/16/2022 • 2 minutes to read • Edit Online

The following table links to Java source you can use to manage SQL Database.

SA M P L E DESC RIP T IO N

Connect and query data from Azure SQL Database using Configure a sample database, then run select, insert, update,
JDBC and delete commands.

Create and manage SQL databases Create SQL databases, set performance levels, and configure
firewalls.

Manage SQL databases across multiple regions Create a master SQL database and read-only databases
from the master in multiple regions. Connect VMs to their
nearest SQL database instance with a virtual network and
firewall rules.
 Java source samples for Azure Active Directory
2/16/2022 • 2 minutes to read • Edit Online

The following table links to Java source you can use to access and work with Azure Active Directory (AD) in your
apps.

SA M P L E DESC RIP T IO N

Integrating Azure AD into a Java web application Set up OAuth2 authentication in a Java web app.

Integrating Azure AD into a Java command line using Obtain a JWT access token through OAuth 2.0, then use the
username and password access token to authenticate with an Azure AD protected
web API.

Manage users, groups, and roles with the Graph API Manage users, groups, roles, and service principals with the
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
2/16/2022 • 2 minutes to read • Edit Online

The following table links to Java source you can use to create and configure applications running in Azure
Container Service.

SA M P L E DESC RIP T IO N

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 Registry into a new Deploy a Docker image running Tomcat to a new web app
Linux Web App running in Azure App Service for Linux.
 Azure SDK for Java libraries
2/16/2022 • 44 minutes to read • Edit Online

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

NAME PA C K A GE DO C S SO URC E

azure-verticals-agrifood- Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

farming

Anomaly Detector Maven 3.0.0-beta.4 docs GitHub 3.0.0-beta.4

App Configuration Maven 1.3.0 docs GitHub 1.3.0

Attestation Maven 1.0.0 docs GitHub 1.0.0

Azure Mixed Reality Maven 1.1.5 docs GitHub 1.1.5

Authentication

Azure Remote Rendering Maven 1.1.4 docs GitHub 1.1.4

Azure Video Analyzer Edge Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Cognitive Search Maven 11.4.7 docs GitHub 11.4.7

Maven 11.5.0-beta.6 GitHub 11.5.0-beta.6

Communication Chat Maven 1.1.4 docs GitHub 1.1.4

Communication Common Maven 1.0.8 docs GitHub 1.0.8

Communication Identity Maven 1.1.6 docs GitHub 1.1.6

Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Communication Network Maven 1.0.0 docs GitHub 1.0.0

Traversal
NAME PA C K A GE DO C S SO URC E

Communication Phone Maven 1.0.7 docs GitHub 1.0.7

Numbers Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Communication Sms Maven 1.0.7 docs GitHub 1.0.7

Confidential Ledger Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Container Registry Maven 1.0.1 docs GitHub 1.0.1

Core Maven 1.25.0 docs GitHub 1.25.0

Core - AMQP Maven 2.4.0 docs GitHub 2.4.0

Core - HTTP Netty Maven 1.11.7 docs GitHub 1.11.7

Core - HTTP OkHttp Maven 1.7.9 docs GitHub 1.7.9

Core - Test Maven 1.7.8 docs GitHub 1.7.8

Core Experimental Maven 1.0.0-beta.24 docs GitHub 1.0.0-beta.24

Core Serializer Apache Avro Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Core Serializer Apache Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Jackson

Core Serializer GSON JSON Maven 1.1.12 docs GitHub 1.1.12

Core Serializer Jackson Maven 1.2.13 docs GitHub 1.2.13

JSON

Cosmos DB Maven 4.26.0 docs GitHub 4.26.0

Cosmos DB Encryption Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

Digital Twins - Core Maven 1.1.6 docs GitHub 1.1.6

Document Translation Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Event Grid Maven 4.9.0 docs GitHub 4.9.0

Event Hubs Maven 5.11.0 docs GitHub 5.11.0

Event Hubs - Azure Blob Maven 1.11.0 docs GitHub 1.11.0

Storage Checkpoint Store

Form Recognizer Maven 3.1.8 docs GitHub 3.1.8

Maven 4.0.0-beta.4 GitHub 4.0.0-beta.4

Identity Maven 1.4.4 docs GitHub 1.4.4

NAME PA C K A GE DO C S SO URC E

IoT Device Update Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Key Vault - Administration Maven 4.0.7 docs GitHub 4.0.7

Maven 4.1.0-beta.5 GitHub 4.1.0-beta.5

Key Vault - Certificates Maven 4.2.7 docs GitHub 4.2.7

Maven 4.3.0-beta.5 GitHub 4.3.0-beta.5

Key Vault - Keys Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.7 GitHub 4.4.0-beta.7

Key Vault - Secrets Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.5 GitHub 4.4.0-beta.5

Metrics Advisor Maven 1.0.5 docs GitHub 1.0.5

Monitor OpenTelemetry Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Exporter

Monitor Query Maven 1.0.3 docs GitHub 1.0.3

Purview Account Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Purview Catalog 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

Schema Registry Maven 1.0.2 docs GitHub 1.0.2

Schema Registry - Avro Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

Schema Registry - Avro Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

SDK - Bill of Materials Maven 1.1.0 GitHub 1.1.0

Service Bus Maven 7.6.0 docs GitHub 7.6.0

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs Batch Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Blobs Changefeed Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Cryptography Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs NIO Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Common Maven 12.14.3 docs GitHub 12.14.3

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3
NAME PA C K A GE DO C S SO URC E

Storage - Files Data Lake Maven 12.7.4 docs GitHub 12.7.4

Maven 12.8.0-beta.3 GitHub 12.8.0-beta.3

Storage - Files Shares Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Internal Avro Maven 12.1.4 docs GitHub 12.1.4

Maven 12.2.0-beta.3 GitHub 12.2.0-beta.3

Storage - Queues Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Synapse - AccessControl Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Synapse - Artifacts Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

Synapse - Managed Private Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Endpoints

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

Tables Maven 12.2.0 docs GitHub 12.2.0

Text Analytics Maven 5.1.6 docs GitHub 5.1.6

Maven 5.2.0-beta.2 GitHub 5.2.0-beta.2

Tracing OpenTelemetry Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Plugin

Web PubSub Maven 1.0.2 docs GitHub 1.0.2

Management - Core Maven 1.5.2 docs GitHub 1.5.2

Resource Management Maven 2.12.0 docs GitHub 2.12.0

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Advisor

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

API for FHIR

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Api Management

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

App Configuration

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

App Service
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Application Insights

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Arc Data

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Attestation

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Authorization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Automation

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack HCI

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

BareMetal Infrastructure

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Batch

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Batch AI

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Billing

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Bot Service

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Change Analysis

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cognitive Search

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cognitive Services

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Commerce

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Communication Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Compute
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Confluent

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Connected Cluster

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Consumption

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Instances

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Registry

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Service

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Content Delivery Network

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cosmos DB

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cost Management

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Custom Location

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Customer Insights

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box Edge

Resource Management - Maven 1.0.0-beta.11 docs GitHub 1.0.0-beta.11

Data Factory

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Store

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Data Protection

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Database Migration Service
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Databricks

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Datadog

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Delegated Network

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Deployment Manager

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Desktop Virtualization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Dev Spaces

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Device Provisioning Services Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

DevTest Labs

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Digital Twins

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

DNS

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Elastic

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

Event Grid

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Event Hubs

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Frontdoor

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

HANA on Azure

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

HDInsight

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Health Bot

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Hybrid Cloud Compute
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Hybrid Network

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Image Builder

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

IoT Central

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

IoT Hub Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Key Vault

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kubernetes Configuration

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kusto

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Lab Services

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Loat Test

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Log Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logic Apps

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logz

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Machine Learning Services

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Maintenance

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Managed Applications

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Managed Service Identity

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Maps

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

MariaDB
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Marketplace Agreements

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Media Services Maven 1.1.0-beta.2 GitHub 1.1.0-beta.2

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Mixed Reality

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Monitor

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

MySQL

Resource Management - Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

NetApp Files

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Network

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Notification Hubs

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Operations Management

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Peering

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Policy Insights

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

PostgreSQL

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

PostgreSQL Flexible Server

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Power BI Dedicated

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Private DNS

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Purview

Resource Management - Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

Quota

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Recovery Services
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Recovery Services Backup

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Redis

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Redis Enterprise

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Relay

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Resource Graph

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Health

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Mover

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Resources

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Security Center

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Service Bus

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Service Fabric

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

SignalR

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Spring Cloud

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

SQL

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

SQL Virtual Machine

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Storage

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Storage Cache

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Import/Export
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Pool

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Stream Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Subscription

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Support

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Synapse Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Time Series Insights

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Traffic Manager

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Video Analyzer

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

VMware Solution

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

VMware Solution by
CloudSimple

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Web PubSub

Azure Identity Spring Maven 1.13.0 GitHub 1.13.0

Azure Spring Boot Maven 3.13.0 GitHub 3.13.0

AutoConfigure

Azure Spring Boot BOM Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory B2C

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Cosmos
NAME PA C K A GE DO C S SO URC E

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Certificates

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Secrets

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Service bus Jms

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Storage

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config
Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Autoconfigure

Azure Spring Cloud Context Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Dependencies

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Core

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Event Hubs

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Service Bus

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Storage Queue

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Test

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Messaging

Azure Spring Cloud Starter Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config
 NAME PA C K A GE DO C S SO URC E

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Cache

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs Kafka

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Service bus

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Storage Queue

Azure Spring Cloud Storage Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Event Hubs

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Core

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Queue

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Topic

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Test

Azure Spring Cloud Maven 2.5.0 GitHub 2.5.0

Telemetry

Key Vault - JCA Maven 2.5.0 docs GitHub 2.5.0

Spring Data Cosmos Maven 3.18.0 docs GitHub 3.18.0

All libraries
NAME PA C K A GE DO C S SO URC E

azure-verticals-agrifood- Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

farming

Anomaly Detector Maven 3.0.0-beta.4 docs GitHub 3.0.0-beta.4

App Configuration Maven 1.3.0 docs GitHub 1.3.0

Attestation Maven 1.0.0 docs GitHub 1.0.0

NAME PA C K A GE DO C S SO URC E

Azure Mixed Reality Maven 1.1.5 docs GitHub 1.1.5

Authentication

Azure Remote Rendering Maven 1.1.4 docs GitHub 1.1.4

Azure Video Analyzer Edge Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Cognitive Search Maven 11.4.7 docs GitHub 11.4.7

Maven 11.5.0-beta.6 GitHub 11.5.0-beta.6

Communication Chat Maven 1.1.4 docs GitHub 1.1.4

Communication Common Maven 1.0.8 docs GitHub 1.0.8

Communication Identity Maven 1.1.6 docs GitHub 1.1.6

Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Communication Network Maven 1.0.0 docs GitHub 1.0.0

Traversal

Communication Phone Maven 1.0.7 docs GitHub 1.0.7

Numbers Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Communication Sms Maven 1.0.7 docs GitHub 1.0.7

Confidential Ledger Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Container Registry Maven 1.0.1 docs GitHub 1.0.1

Core Maven 1.25.0 docs GitHub 1.25.0

Core - AMQP Maven 2.4.0 docs GitHub 2.4.0

Core - HTTP Netty Maven 1.11.7 docs GitHub 1.11.7

Core - HTTP OkHttp Maven 1.7.9 docs GitHub 1.7.9

Core - Test Maven 1.7.8 docs GitHub 1.7.8

Core Experimental Maven 1.0.0-beta.24 docs GitHub 1.0.0-beta.24

Core Serializer Apache Avro Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Core Serializer Apache Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Jackson

Core Serializer GSON JSON Maven 1.1.12 docs GitHub 1.1.12

Core Serializer Jackson Maven 1.2.13 docs GitHub 1.2.13

JSON
NAME PA C K A GE DO C S SO URC E

Cosmos DB Maven 4.26.0 docs GitHub 4.26.0

Cosmos DB Encryption Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

Digital Twins - Core Maven 1.1.6 docs GitHub 1.1.6

Document Translation Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Event Grid Maven 4.9.0 docs GitHub 4.9.0

Event Hubs Maven 5.11.0 docs GitHub 5.11.0

Event Hubs - Azure Blob Maven 1.11.0 docs GitHub 1.11.0

Storage Checkpoint Store

Form Recognizer Maven 3.1.8 docs GitHub 3.1.8

Maven 4.0.0-beta.4 GitHub 4.0.0-beta.4

Identity Maven 1.4.4 docs GitHub 1.4.4

IoT Device Update Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Key Vault - Administration Maven 4.0.7 docs GitHub 4.0.7

Maven 4.1.0-beta.5 GitHub 4.1.0-beta.5

Key Vault - Certificates Maven 4.2.7 docs GitHub 4.2.7

Maven 4.3.0-beta.5 GitHub 4.3.0-beta.5

Key Vault - Keys Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.7 GitHub 4.4.0-beta.7

Key Vault - Secrets Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.5 GitHub 4.4.0-beta.5

Metrics Advisor Maven 1.0.5 docs GitHub 1.0.5

Monitor OpenTelemetry Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Exporter

Monitor Query Maven 1.0.3 docs GitHub 1.0.3

Purview Account Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Purview Catalog 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

Schema Registry Maven 1.0.2 docs GitHub 1.0.2

Schema Registry - Avro Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

NAME PA C K A GE DO C S SO URC E

Schema Registry - Avro Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

SDK - Bill of Materials Maven 1.1.0 GitHub 1.1.0

Service Bus Maven 7.6.0 docs GitHub 7.6.0

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs Batch Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Blobs Changefeed Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Cryptography Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs NIO Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Common Maven 12.14.3 docs GitHub 12.14.3

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Files Data Lake Maven 12.7.4 docs GitHub 12.7.4

Maven 12.8.0-beta.3 GitHub 12.8.0-beta.3

Storage - Files Shares Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Internal Avro Maven 12.1.4 docs GitHub 12.1.4

Maven 12.2.0-beta.3 GitHub 12.2.0-beta.3

Storage - Queues Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Synapse - AccessControl Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Synapse - Artifacts Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

Synapse - Managed Private Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Endpoints

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

Tables Maven 12.2.0 docs GitHub 12.2.0

Text Analytics Maven 5.1.6 docs GitHub 5.1.6

Maven 5.2.0-beta.2 GitHub 5.2.0-beta.2

Tracing OpenTelemetry Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Plugin
NAME PA C K A GE DO C S SO URC E

Web PubSub Maven 1.0.2 docs GitHub 1.0.2

Management - Core Maven 1.5.2 docs GitHub 1.5.2

Resource Management Maven 2.12.0 docs GitHub 2.12.0

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Advisor

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

API for FHIR

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Api Management

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

App Configuration

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

App Service

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Application Insights

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Arc Data

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Attestation

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Authorization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Automation

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack HCI

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

BareMetal Infrastructure

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Batch

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Batch AI

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Billing
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Bot Service

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Change Analysis

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cognitive Search

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cognitive Services

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Commerce

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Communication Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Compute

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Confluent

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Connected Cluster

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Consumption

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Instances

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Registry

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Service

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Content Delivery Network

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cosmos DB

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cost Management

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Custom Location

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Customer Insights
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box Edge

Resource Management - Maven 1.0.0-beta.11 docs GitHub 1.0.0-beta.11

Data Factory

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Store

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Data Protection

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Database Migration Service

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Databricks

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Datadog

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Delegated Network

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Deployment Manager

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Desktop Virtualization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Dev Spaces

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Device Provisioning Services Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

DevTest Labs

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Digital Twins

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

DNS

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Elastic
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

Event Grid

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Event Hubs

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Frontdoor

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

HANA on Azure

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

HDInsight

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Health Bot

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Hybrid Cloud Compute

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Hybrid Network

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Image Builder

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

IoT Central

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

IoT Hub Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Key Vault

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kubernetes Configuration

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kusto

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Lab Services

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Loat Test

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Log Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logic Apps
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logz

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Machine Learning Services

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Maintenance

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Managed Applications

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Managed Service Identity

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Maps

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

MariaDB

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Marketplace Agreements

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Media Services Maven 1.1.0-beta.2 GitHub 1.1.0-beta.2

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Mixed Reality

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Monitor

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

MySQL

Resource Management - Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

NetApp Files

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Network

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Notification Hubs

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Operations Management

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Peering

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Policy Insights
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

PostgreSQL

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

PostgreSQL Flexible Server

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Power BI Dedicated

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Private DNS

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Purview

Resource Management - Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

Quota

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Recovery Services

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Recovery Services Backup

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Redis

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Redis Enterprise

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Relay

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Resource Graph

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Health

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Mover

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Resources

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Security Center

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Service Bus

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Service Fabric
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

SignalR

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Spring Cloud

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

SQL

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

SQL Virtual Machine

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Storage

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Storage Cache

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Import/Export

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Pool

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Stream Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Subscription

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Support

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Synapse Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Time Series Insights

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Traffic Manager

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Video Analyzer

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

VMware Solution

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

VMware Solution by
CloudSimple

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Web PubSub
NAME PA C K A GE DO C S SO URC E

Azure Identity Spring Maven 1.13.0 GitHub 1.13.0

Azure Spring Boot Maven 3.13.0 GitHub 3.13.0

AutoConfigure

Azure Spring Boot BOM Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory B2C

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Cosmos

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Certificates

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Secrets

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Service bus Jms

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Storage

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config
Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Autoconfigure

Azure Spring Cloud Context Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Dependencies

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Core
NAME PA C K A GE DO C S SO URC E

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Event Hubs

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Service Bus

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Storage Queue

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Test

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Messaging

Azure Spring Cloud Starter Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Cache

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs Kafka

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Service bus

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Storage Queue

Azure Spring Cloud Storage Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Event Hubs

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Core

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Queue

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Topic

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Test

Azure Spring Cloud Maven 2.5.0 GitHub 2.5.0

Telemetry
NAME PA C K A GE DO C S SO URC E

Key Vault - JCA Maven 2.5.0 docs GitHub 2.5.0

Spring Data Cosmos Maven 3.18.0 docs GitHub 3.18.0

azure-analytics-purview- Maven 1.0.0-beta.1

administration

azure-autorest- Maven 1.0.0-beta.4

customization

azure-autorest-extension Maven 1.0.0-beta.1

azure-autorest-parent Maven 1.0.0-beta.1

azure-communication- Maven 1.0.0-beta.4

administration

azure-communication- Maven 1.0.0-beta.4

callingserver

azure-cosmos-cassandra- Maven 1.0.1

driver-3

azure-cosmos-cassandra- Maven 0.14.0

driver-3

azure-cosmos-cassandra- Maven 1.0.1

driver-3-extensions

azure-cosmos-cassandra- Maven 1.1.0

driver-4

azure-cosmos-cassandra- Maven 1.1.0

driver-4-extensions

azure-cosmos-cassandra- Maven 1.1.0

spring-data-extensions

azure-cosmos-spark_3-0_2- Maven 4.0.0-beta.1

12

azure-cosmos-spark_3-1_2- Maven 4.6.1

12

azure-cosmos-spark_3-2_2- Maven 4.6.1

12

azure-data- Maven 1.0.0-beta.1

confidentialledger

azure-gradle-plugins- Maven 1.1.2

common
NAME PA C K A GE DO C S SO URC E

azure-mariadb-connector- Maven 2.7.0

java

azure-maven-plugins Maven 1.15.0

azure-mgmt-appplatform Maven 1.0.0-beta

azure-mgmt-appservice Maven 1.0.0-beta

azure-mgmt-cdn Maven 1.0.0-beta

azure-mgmt-compute Maven 1.0.0-beta

azure-mgmt-compute Maven 1.0.0-beta

azure-mgmt- Maven 1.0.0-beta

containerinstance

azure-mgmt- Maven 1.0.0-beta

containerservice

azure-mgmt-cosmosdb Maven 1.0.0-beta

azure-mgmt-digitaltwins Maven 1.0.0

azure-mgmt- Maven 1.0.0

kubernetesconfiguration

azure-mgmt-mixedreality Maven 1.0.0-beta

azure-mgmt-mysql Maven 1.0.0-beta

azure-mgmt-netapp Maven 1.0.0-beta

azure-mgmt-network Maven 1.0.0-beta

azure-mgmt-network Maven 1.0.0-beta

azure-mgmt-resourcemover Maven 1.0.0

azure-mgmt-storagecache Maven 1.0.0-beta

azure-mgmt- Maven 1.0.0-beta

streamanalytics

azure-mgmt-synapse Maven 1.0.0

azure-opentelemetry- Maven 1.0.0-beta.2

exporter-azuremonitor

azure-quantum-jobs Maven 1.0.0-beta.1

NAME PA C K A GE DO C S SO URC E

azure-resourcemanager- Maven 1.0.0-beta.1

oep

azure-sdk-archetype Maven 1.0.0

azure-storage-fastpath Maven 1.0.0-beta.5

azure-toolkit- Maven 0.16.0

applicationinsights-lib

azure-toolkit-appservice-lib Maven 0.16.0

azure-toolkit-auth-lib Maven 0.16.0

azure-toolkit-common-lib Maven 0.16.0

azure-toolkit-compute-lib Maven 0.16.0

azure-toolkit-database-lib Maven 0.16.0

azure-toolkit-libs Maven 0.16.0

azure-toolkit-mysql-lib Maven 0.16.0

azure-toolkit-postgre-lib Maven 0.16.0

azure-toolkit-redis-lib Maven 0.16.0

azure-toolkit-resource-lib Maven 0.16.0

azure-toolkit-springcloud- Maven 0.16.0

lib

azure-toolkit-sqlserver-lib Maven 0.16.0

azure-toolkit-storage-lib Maven 0.16.0

azure-verticals-agrifood- Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

farming

codesnippet-maven-plugin Maven 1.0.0-beta.6

IoT Models Repository Maven 1.0.0-beta.1

notification-hubs-android- Maven 1.1.6

sdk

notification-hubs-android- Maven 1.1.6

sdk-fcm
NAME PA C K A GE DO C S SO URC E

spark-mssql- Maven 1.0.2

connector_2.11_2.4

spark-mssql- Maven 1.2.0

connector_2.12

spring-cloud-azure- Maven 4.0.0-beta.3

dependencies

spring-cloud-azure-starter- Maven 4.0.0-beta.3

active-directory

spring-cloud-azure-starter- Maven 4.0.0-beta.3

active-directory-b2c

spring-cloud-azure-starter- Maven 4.0.0-beta.3

appconfiguration

spring-cloud-azure-starter- Maven 4.0.0-beta.3

cosmos

spring-cloud-azure-starter- Maven 4.0.0-beta.3

data-cosmos

spring-cloud-azure-starter- Maven 4.0.0-beta.2

eventhubs

spring-cloud-azure-starter- Maven 4.0.0-beta.2

integration-eventhubs

spring-cloud-azure-starter- Maven 4.0.0-beta.3

integration-servicebus

spring-cloud-azure-starter- Maven 4.0.0-beta.2

integration-storage-queue

spring-cloud-azure-starter- Maven 4.0.0-beta.2

keyvault-secrets

spring-cloud-azure-starter- Maven 4.0.0-beta.2

servicebus

spring-cloud-azure-starter- Maven 4.0.0-beta.2

servicebus-jms

spring-cloud-azure-starter- Maven 4.0.0-beta.2

storage-blob

spring-cloud-azure-starter- Maven 4.0.0-beta.2

storage-file-share

spring-cloud-azure-starter- Maven 4.0.0-beta.3

storage-queue
NAME PA C K A GE DO C S SO URC E

spring-cloud-azure-starter- Maven 4.0.0-beta.3

stream-eventhubs

spring-cloud-azure-starter- Maven 4.0.0-beta.3

stream-servicebus

spring-cloud-azure-stream- Maven 4.0.0-beta.3

binder-eventhubs

spring-cloud-azure-stream- Maven 4.0.0-beta.3

binder-servicebus

spring-cloud-azure-stream- Maven 4.0.0-beta.3

binder-servicebus-core

spring-cloud-azure-trace- Maven 4.0.0-beta.3

sleuth

spring-integration-azure- Maven 4.0.0-beta.3

core

spring-integration-azure- Maven 4.0.0-beta.3

eventhubs

spring-integration-azure- Maven 4.0.0-beta.3

servicebus

spring-integration-azure- Maven 4.0.0-beta.3

storage-queue

spring-messaging-azure- Maven 4.0.0-beta.3

servicebus

synapseml Maven 0.9.3

synapseml_2.12 Maven 0.9.5

synapseml-cognitive Maven 0.9.3

synapseml-cognitive_2.12 Maven 0.9.5

synapseml-core Maven 0.9.3

synapseml-core_2.12 Maven 0.9.5

synapseml-deep-learning Maven 0.9.3

synapseml-deep- Maven 0.9.5

learning_2.12

synapseml-lightgbm Maven 0.9.3

NAME PA C K A GE DO C S SO URC E

synapseml-lightgbm_2.12 Maven 0.9.5

synapseml-opencv Maven 0.9.3

synapseml-opencv_2.12 Maven 0.9.5

synapseml-vw Maven 0.9.3

synapseml-vw_2.12 Maven 0.9.5

synapseutils Maven 1.1

synapseutils_2.11 Maven 1.4

synapseutils_2.12 Maven 1.4

Troposphere Maven Plugin Maven 2.6.0.1

Active Directory Maven 1.6.7 docs

Authentication Library4J

Actors Maven 1.0.0

Annotations Maven 1.10.0

Anomaly Detector Maven 3.0.0-beta.4 docs GitHub 3.0.0-beta.4

Apache Spark Archetype Maven 0.1.0

App Configuration Maven 1.3.0 docs GitHub 1.3.0

Application Insights - Agent Maven 3.2.6

Application Insights - Maven 2.6.3

Collectd Maven 2.6.3-BETA-HEYA-
TEST

Application Insights - Core Maven 2.6.3

Maven 2.6.3-BETA-HEYA-
TEST

Application Insights - Maven 2.6.3

Logging Log4j1_2

Application Insights - Maven 2.6.3

Logging Log4j2

Application Insights - Maven 2.6.3

Logging Logback

Application Insights - Maven 0.2.0

Profiler Agent
NAME PA C K A GE DO C S SO URC E

Application Insights - Maven 0.2.0

Profiler Library

Application Insights - Maven 0.2.1

Profiler Telemetrymodule

Application Insights - Maven 0.2.0

Profiler Uploader

Application Insights - Maven 1.0.0-Preview-1

Query

Application Insights - Maven 2.6.3

Spring Boot Starter Maven 2.6.3-BETA-HEYA-
TEST

Application Insights - Web Maven 2.6.3

Maven 2.6.3-BETA-HEYA-
TEST

Application Insights - Web Maven 2.6.3

Auto Maven 2.6.3-BETA-HEYA-
TEST

Attestation Maven 1.0.0 docs GitHub 1.0.0

Auth Helper Plugin Maven 0.7.0

Authentication - Managed Maven 1.0.0-Beta-2 GitHub 1.0.0-Beta-2

Service Identity Token
Provider

AutoRest Build Tools Maven 1.7.14

AutoRest Client Runtime for Maven 2.1.1

Java

Autosuggest Maven 1.0.2-beta GitHub 1.0.2-beta

Azure Maven 1.41.2

Azure Functions Java Maven 1.0.0

Library RabbitMQ

Azure Mixed Reality Maven 1.1.5 docs GitHub 1.1.5

Authentication

Azure Profile hybrid Maven 1.0.0-beta-1

Azure Remote Rendering Maven 1.1.4 docs GitHub 1.1.4

Azure Video Analyzer Edge Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

NAME PA C K A GE DO C S SO URC E

Batch Maven 10.0.0 docs GitHub 10.0.0

Bill of Materials Maven 1.0.0.M1

Bill of Materials Maven 2.3.0

Bundler Maven Plugin Maven 0.0.5

Client Authentication Maven 1.7.14

Client Runtime Maven 1.7.14

Cognitive Search Maven 11.4.7 docs GitHub 11.4.7

Maven 11.5.0-beta.6 GitHub 11.5.0-beta.6

Cognitive Services - Parent Maven 1.0.2

Communication Chat Maven 1.1.4 docs GitHub 1.1.4

Communication Common Maven 1.0.8 docs GitHub 1.0.8

Communication Identity Maven 1.1.6 docs GitHub 1.1.6

Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Communication Network Maven 1.0.0 docs GitHub 1.0.0

Traversal

Communication Phone Maven 1.0.7 docs GitHub 1.0.7

Numbers Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Communication Sms Maven 1.0.7 docs GitHub 1.0.7

Computer Vision Maven 1.0.9-beta GitHub 1.0.9-beta

Confidential Ledger Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Container Registry Maven 1.0.1 docs GitHub 1.0.1

Content Moderator Maven 1.0.2-beta GitHub 1.0.2-beta

Core Maven 1.25.0 docs GitHub 1.25.0

Core Maven 0.9.8 docs

Core - AMQP Maven 2.4.0 docs GitHub 2.4.0

Core - HTTP Netty Maven 1.11.7 docs GitHub 1.11.7

Core - HTTP OkHttp Maven 1.7.9 docs GitHub 1.7.9

Core - Parent Maven 1.0.0-preview.2

NAME PA C K A GE DO C S SO URC E

Core - Test Maven 1.7.8 docs GitHub 1.7.8

Core - Tracing OpenCensus Maven 1.0.0-preview.4 GitHub 1.0.0-preview.4

Core Experimental Maven 1.0.0-beta.24 docs GitHub 1.0.0-beta.24

Core Serializer Apache Avro Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Core Serializer Apache Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Jackson

Core Serializer GSON JSON Maven 1.1.12 docs GitHub 1.1.12

Core Serializer Jackson Maven 1.2.13 docs GitHub 1.2.13

JSON

Cosmos DB Maven 4.26.0 docs GitHub 4.26.0

Cosmos DB Maven 3.7.6 docs GitHub 3.7.6

Cosmos DB - Cassandra Maven 0.14.0

Extensions

Cosmos DB - Cassandra Maven 0.13.0

Extensions Parent

Cosmos DB - Cassandra Maven 1.2.0

Spark Helper

Cosmos DB - Cassandra Maven 1.0.16

Uploader

Cosmos DB - Change Feed Maven 1.0.0-beta-2

Cosmos DB - Change Feed Maven 0.9.2-sources

Processor

Cosmos DB - Commons Maven 3.0.0-beta-3

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 - Parent Maven 4.0.0-preview.2

Cosmos DB - Parent Maven 3.5.0

Cosmos DB - Serialization Maven 2.9.6

NAME PA C K A GE DO C S SO URC E

Cosmos DB - Spark Maven 3.7.0

Cosmos DB Encryption Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

Custom Image Search Maven 1.0.2-beta GitHub 1.0.2-beta

Custom Search Maven 1.0.2 GitHub 1.0.2

Custom Vision Prediction Maven 1.1.0-preview.2

Custom Vision Prediction Maven 1.0.2-beta GitHub 1.0.2-beta

Custom Vision Training Maven 1.1.0-preview.2

Custom Vision Training Maven 1.0.2-beta GitHub 1.0.2-beta

Data Lake Storage Maven 2.3.9 docs

Digital Twins - Core Maven 1.1.6 docs GitHub 1.1.6

Digital Twins Device Client Maven 1.0.0

Preview

Document DB Maven 2.6.4 docs

Document DB - Bulk Maven 2.12.5

Executor

Document DB - Bulk Maven 1.0.2

Import

Document DB - Hadoop Maven 1.2.0

Document DB - Reactive Maven 0.9.0-rc2

Extension

Document DB - Spring Boot Maven 0.1.7

Auto Configure

Document DB - Spring Boot Maven 2.0.5

Starter

Document Translation Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Elastic Database Tools Maven 1.0.0

Entity Search Maven 1.0.2 GitHub 1.0.2

Event Grid Maven 1.4.0 GitHub 1.4.0

Event Grid Maven 4.9.0 docs GitHub 4.9.0

NAME PA C K A GE DO C S SO URC E

Event Hubs Maven 3.3.0 GitHub 3.3.0

Event Hubs Maven 5.11.0 docs GitHub 5.11.0

Event Hubs - Azure Blob Maven 1.11.0 docs GitHub 1.11.0

Storage Checkpoint Store

Event Hubs - Databricks Maven 3.4.0

Event Hubs - Event Maven 3.3.0 GitHub 3.3.0

Processor

Event Hubs - Extensions Maven 3.3.0 GitHub 3.3.0

Event Hubs - Parent Maven 5.0.0-preview.1

Event Hubs - Reactive Maven 0.5.0

Event Hubs - Spark Maven 2.3.21

Face Maven 1.0.0-beta GitHub 1.0.0-beta

Form Recognizer Maven 3.1.8 docs GitHub 3.1.8

Maven 4.0.0-beta.4 GitHub 4.0.0-beta.4

Functions - Archetype Maven 1.43

Functions - Java Core Maven 1.0.0-beta-3

Functions - Java Library Maven 1.0.0

Cosmos DB Cassandra

Functions - Java Library Maven 1.0.0

SignalR

Functions - Java Llibrary Maven 1.4.2

Functions - Kotlin Maven 1.23

Archetype

Functions - Maven Plugin Maven 1.15.0

Gateway - Java Binding Maven 1.1.0

Gateway - Linux Maven 1.0.2

Gateway - Module Base Maven 1.0.2

Gateway - Module Simple Maven 1.0.0

Gateway - Win32 Maven 1.0.2

NAME PA C K A GE DO C S SO URC E

Identity Maven 1.4.4 docs GitHub 1.4.4

Image Search Maven 1.0.2 GitHub 1.0.2

Internet Analyzer Java Maven 1.0.0-beta.1

IoT Deps Maven 2.0.0-preview-001

IoT Device Client Maven 1.32.1

Maven 2.0.0-preview-002

IoT Device Update Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

IoT Edge Archetype Maven 1.3.0

IoT Service Client Maven 1.33.0 docs

Maven 2.0.0-preview-002

Key Vault - Administration Maven 4.0.7 docs GitHub 4.0.7

Maven 4.1.0-beta.5 GitHub 4.1.0-beta.5

Key Vault - Certificates Maven 4.0.0-preview.4 GitHub 4.0.0-preview.4

Key Vault - Certificates Maven 4.2.7 docs GitHub 4.2.7

Maven 4.3.0-beta.5 GitHub 4.3.0-beta.5

Key Vault - Keys Maven 4.0.0-preview.4 GitHub 4.0.0-preview.4

Key Vault - Keys Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.7 GitHub 4.4.0-beta.7

Key Vault - Secrets Maven 4.0.0-preview.4 GitHub 4.0.0-preview.4

Key Vault - Secrets Maven 4.3.7 docs GitHub 4.3.7

Maven 4.4.0-beta.5 GitHub 4.4.0-beta.5

Kusto Data Maven 3.0.0

Kusto Ingest Maven 3.0.0

Kusto Spark Maven 2.9.3

Log Analytics Maven 1.0.0-Preview-1 GitHub 1.0.0-Preview-1

LUIS Maven 0.0.1-beta

LUIS Authoring Maven 1.0.4-beta GitHub 1.0.4-beta

LUIS Runtime Maven 1.0.2-beta GitHub 1.0.2-beta

MASL4J Maven 1.11.2

NAME PA C K A GE DO C S SO URC E

MASL4J Persistence Maven 1.1.0

Extension

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.14.3

Maven - Plugins Pom Maven 1.1.0

Media Services Maven 0.9.8 GitHub 0.9.8

Metrics Advisor Maven 1.0.5 docs GitHub 1.0.5

Monitor OpenTelemetry Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Exporter

Monitor Query Maven 1.0.3 docs GitHub 1.0.3

Native Maven 1.0.0

News Search Maven 1.0.2 GitHub 1.0.2

Parent Maven 1.41.2

Profile - Parent Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Provisioning Device Client Maven 1.10.0

Maven 2.0.0-preview-002

Provisioning Service Client Maven 1.9.0

Maven 2.0.0-preview-002

Purview Account Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Purview Catalog 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

QnA Maker Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

Qpid Proton J Extensions Maven 1.2.4

Relay Maven 0.0.3

Schema Registry Maven 1.0.2 docs GitHub 1.0.2

Schema Registry - Avro Maven 1.0.0-beta.9 docs GitHub 1.0.0-beta.9

NAME PA C K A GE DO C S SO URC E

Schema Registry - Avro Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Schema Registry - Kafka Maven 1.0.0-beta.4

Avro

SDK - Bill of Materials Maven 1.1.0 GitHub 1.1.0

Search Maven 11.0.0-beta.1 GitHub 11.0.0-beta.1

Security Provider Maven 1.5.0

Maven 2.0.0-preview-001

Service Bus Maven 7.6.0 docs GitHub 7.6.0

Service Bus Maven 3.6.6 GitHub 3.6.6

Service Bus - JMS Maven 0.0.9

Service Bus - JMS Maven 0.0.1

Connection Factory

Service Fabric Maven 1.0.0

Service Fabric Mesh Maven Maven 0.1.0

Plugin

Service Runtime Maven 0.9.8

Session Management - Maven 1.0.0-beta.1

Project

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 Maven 2.1.5

Eventhubs

Spark - Streaming Maven 2.1.4

Eventhubs Connector

Spark - Streaming Maven 2.1.4

Eventhubs Examples

Spell Check Maven 1.0.2 GitHub 1.0.2

Spring Cloud Maven Plugin Maven 1.8.0

NAME PA C K A GE DO C S SO URC E

Spring Data Azure Maven 0.1.1

CosmosDB DocumentDB

Spring Data Azure Maven 0.1.7

DocumentDB

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

SQLDB Spark Maven 1.0.2

Storage Maven 8.6.6 docs

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs Maven 11.0.1 docs GitHub 11.0.1

Storage - Blobs Batch Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Blobs Changefeed Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Blobs Maven 12.14.4 docs GitHub 12.14.4

Cryptography Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Blobs NIO Maven 12.0.0-beta.16 docs GitHub 12.0.0-beta.16

Storage - Common Maven 12.14.3 docs GitHub 12.14.3

Maven 12.15.0-beta.3 GitHub 12.15.0-beta.3

Storage - Files Data Lake Maven 12.7.4 docs GitHub 12.7.4

Maven 12.8.0-beta.3 GitHub 12.8.0-beta.3

Storage - Files Shares Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Internal Avro Maven 12.1.4 docs GitHub 12.1.4

Maven 12.2.0-beta.3 GitHub 12.2.0-beta.3

Storage - Java Maven 10

Storage - Queues Maven 12.11.4 docs GitHub 12.11.4

Maven 12.12.0-beta.3 GitHub 12.12.0-beta.3

Storage - Queues Maven 10.0.1-Preview docs

Support Maven 0.1.8

NAME PA C K A GE DO C S SO URC E

Synapse - AccessControl Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Synapse - Artifacts Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

Synapse - Managed Private Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Endpoints

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 Fabric Maven 1.0.0

Tables Maven 12.2.0 docs GitHub 12.2.0

Text Analytics Maven 5.1.6 docs GitHub 5.1.6

Maven 5.2.0-beta.2 GitHub 5.2.0-beta.2

Text Analytics Maven 1.0.2-beta GitHub 1.0.2-beta

Tools common Maven 0.14.0

TPM Provider Maven 1.1.3

Maven 2.0.0-preview-001

TPM Software Stack Java Maven 1.0.0

Tracing OpenTelemetry Maven 1.0.0-beta.20 docs GitHub 1.0.0-beta.20

Plugin

Tracing Util Maven 0.9.8

Transport Maven 1.0.0

Video Search Maven 1.0.2 GitHub 1.0.2

Visual Search Maven 1.0.2-beta GitHub 1.0.2-beta

Web PubSub Maven 1.0.2 docs GitHub 1.0.2

Web Search Maven 1.0.2 GitHub 1.0.2

Webapp Maven Plugin Maven 2.3.0

Webapp Maven Plugin Maven 0.1.1

Websocket Transport Layer Maven 0.1.3

X509 Provider Maven 1.1.6

Maven 2.0.0-preview-001
NAME PA C K A GE DO C S SO URC E

Management Maven 0.8.0

Management - Advisor Maven 1.0.0-beta

Management - API Maven 1.0.0-beta GitHub 1.0.0-beta

Management

Management - App Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Configuration

Management - App Maven 1.0.0-beta GitHub 1.0.0-beta

Platform

Management - App Service Maven 1.41.2 docs

Management - Attestation Maven 1.0.0-beta-1

Management - Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Authorization

Management - Azure Stack Maven 1.0.0

HCI

Management - Azure Maven 1.0.0 GitHub 1.0.0

VMware Solution

Management - Batch Maven 1.41.2

Management - Batch AI Maven 1.41.2

Management - Billing Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Cognitive Maven 1.0.1 GitHub 1.0.1

Services

Management - Commerce Maven 1.0.0-beta

Management - Maven 1.0.0-beta

Communication

Management - Compute Maven 1.41.2 docs

Management - Container Maven 1.41.2

Instances

Management - Container Maven 1.41.2

Registry

Management - Container Maven 1.41.2

Service
NAME PA C K A GE DO C S SO URC E

Management - Content Maven 1.41.2 docs

Delivery Network

Management - Core Maven 1.5.2 docs GitHub 1.5.2

Management - Cosmos DB Maven 1.41.2

Management - Cost Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Data Box Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Data Box Maven 1.0.0-beta GitHub 1.0.0-beta

Edge

Management - Data Maven 1.0.0-beta-7 GitHub 1.0.0-beta-7

Factory

Management - Data Lake Maven 1.22.0 docs

Analytics

Management - Data Lake Maven 1.22.0

Storage

Management - Data Maven 1.0.0-beta-2 GitHub 1.0.0-beta-2

Migration

Management - Maven 1.0.0-beta

DataBoxEdge

Management - Deployment Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Dev Spaces Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Management - DevTest Maven 1.0.0-beta GitHub 1.0.0-beta

Labs

Management - Digital Twins Maven 1.0.0

Maven 1.0.0-beta-1

Management - DNS Maven 1.41.2 docs

Management - Document Maven 1.0.0-beta

DB

Management - Event Grid Maven 1.0.0 GitHub 1.0.0

Management - Event Hub Maven 1.41.2

Management - Event Hubs Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Management - Graph RBAC Maven 1.41.2

NAME PA C K A GE DO C S SO URC E

Management - HANA on Maven 1.0.0-beta-5 GitHub 1.0.0-beta-5

Azure

Management - HDInsight Maven 1.3.8 docs GitHub 1.3.8

Management - Health Care Maven 1.0.0-beta

APIs

Management - Hybrid Maven 1.0.0-beta

Compute

Management - IoT Central Maven 1.0.4 GitHub 1.0.4

Management - IoT Hub Maven 1.0.0-beta

Management - Key Vault Maven 1.41.2 GitHub 1.41.2

Management - Kubernetes Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Configuration

Management - Kusto Maven 1.0.0-beta

Management - Lab Services Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Locks Maven 1.41.2

Management - Log Maven 1.0.0-beta

Analytics

Management - Logic Apps Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Management - Machine Maven 1.0.0-beta GitHub 1.0.0-beta

Learning Services

Management - Maven 1.0.0-beta GitHub 1.0.0-beta

Maintenance

Management - Managed Maven 1.0.0-beta GitHub 1.0.0-beta

Applications

Management - Managed Maven 1.41.2

Service Identity

Management - Maria DB Maven 1.0.0-beta-1

Management - Maria DB Maven 1.0.0-beta

Management - Marketplace Maven 1.0.0-beta GitHub 1.0.0-beta

Ordering

Management - Media Maven 0.8.0

Services
NAME PA C K A GE DO C S SO URC E

Management - Media Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Services

Management - Media Maven 1.0.0-beta

Services

Management - Mixed Maven 1.0.0-beta GitHub 1.0.0-beta

Reality

Management - Monitor Maven 1.41.2

Management - Monitor Maven 1.0.0-beta

Management - Net App Maven 1.0.0 GitHub 1.0.0

Management - Network Maven 0.8.0

Management - Network Maven 1.41.2 docs

Management - Network Maven 1.0.0-beta

Management - Operations Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Peering Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Policy Maven 1.0.0-beta-2 GitHub 1.0.0-beta-2

Insights

Management - PostgreSQL Maven 1.0.0-beta-5 GitHub 1.0.0-beta-5

Management - Power BI Maven 1.0.0-beta GitHub 1.0.0-beta

Dedicated

Management - Private DNS Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Recovery Maven 1.0.0-beta

Services

Management - Redis Maven 1.41.2

Management - Relay Maven 1.0.0-beta GitHub 1.0.0-beta

Management - Resource Maven 1.0.0 GitHub 1.0.0

Graph Maven 1.0.0-beta-1

Management - Resource Maven 1.0.0-beta GitHub 1.0.0-beta

Health

Management - Resources Maven 1.41.2 docs

Management - Scheduler Maven 0.8.0

NAME PA C K A GE DO C S SO URC E

Management - Search Maven 1.41.2

Management - Service Bus Maven 1.41.2

Management - Service Maven 1.0.0-beta GitHub 1.0.0-beta

Fabric

Management - SignalR Maven 1.0.0-beta GitHub 1.0.0-beta

Management - SQL Maven 0.8.0

Management - SQL Maven 1.41.2

Management - SQL Virtual Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Machine

Management - Storage Maven 1.41.2

Management - Storage Maven 1.0.0-beta GitHub 1.0.0-beta

Cache

Management - Storage Maven 1.0.0-beta GitHub 1.0.0-beta

Import Export

Management - Stream Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Analytics

Management - Subscription Maven 1.0.0-beta

Management - Maven 1.0.0-beta-1 GitHub 1.0.0-beta-1

Subscriptions

Management - Support Maven 1.0.0 GitHub 1.0.0

Management - Synapse Maven 1.0.0-beta-5 GitHub 1.0.0-beta-5

Management - Time Series Maven 1.0.0-beta GitHub 1.0.0-beta

Insights

Management - Traffic Maven 1.41.2 docs

Manager

Management - VMware Maven 1.0.0-beta GitHub 1.0.0-beta

CloudSimple

Management - Websites Maven 0.8.0

Resource Management Maven 2.12.0 docs GitHub 2.12.0

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Advisor
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

API for FHIR

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Api Management

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

App Configuration

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

App Service

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Application Insights

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Arc Data

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Attestation

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Authorization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Automation

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Azure Stack HCI

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

BareMetal Infrastructure

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Batch

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Batch AI

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Billing

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Bot Service

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Change Analysis

Resource Management - Maven 1.7.14 GitHub 1.7.14

Client Runtime
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cognitive Search

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cognitive Services

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Commerce

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Communication Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Compute

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Confluent

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Connected Cluster

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Consumption

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Instances

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Registry

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Container Service

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Content Delivery Network

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Cosmos DB

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Cost Management

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Custom Location

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Customer Insights

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Box Edge
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.11 docs GitHub 1.0.0-beta.11

Data Factory

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Data Lake Store

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Data Protection

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Database Migration Service

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Databricks

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Datadog

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Delegated Network

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Deployment Manager

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Desktop Virtualization

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Dev Spaces

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Device Provisioning Services Maven 1.1.0-beta.1 GitHub 1.1.0-beta.1

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

DevTest Labs

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Digital Twins

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

DNS

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Elastic

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

Event Grid

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Event Hubs
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Frontdoor

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

HANA on Azure

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

HDInsight

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Health Bot

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Hybrid Cloud Compute

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Hybrid Network

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Image Builder

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

IoT Central

Resource Management - Maven 1.1.0 docs GitHub 1.1.0

IoT Hub Maven 1.2.0-beta.1 GitHub 1.2.0-beta.1

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Key Vault

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kubernetes Configuration

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Kusto

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Lab Services

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Loat Test

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Log Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logic Apps

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Logz

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Machine Learning Services
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Maintenance

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Managed Applications

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Managed Service Identity

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Maps

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

MariaDB

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Marketplace Agreements

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Media Services Maven 1.1.0-beta.2 GitHub 1.1.0-beta.2

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Mixed Reality

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Monitor

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

MySQL

Resource Management - Maven 1.0.0-beta.8 docs GitHub 1.0.0-beta.8

NetApp Files

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Network

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Notification Hubs

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Operations Management

Resource Management - Maven 1.3.2 GitHub 1.3.2

Parent

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Peering

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Policy Insights

Resource Management - Maven 1.0.2 docs GitHub 1.0.2

PostgreSQL
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

PostgreSQL Flexible Server

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Power BI Dedicated

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Private DNS

Resource Management - Maven 1.0.0-beta.1 GitHub 1.0.0-beta.1

Purview

Resource Management - Maven 1.0.0-beta.2 GitHub 1.0.0-beta.2

Quota

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Recovery Services

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

Recovery Services Backup

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Redis

Resource Management - Maven 1.0.0 docs GitHub 1.0.0

Redis Enterprise

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Relay

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Resource Graph

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Health

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Resource Mover

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Resources

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Security Center

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Service Bus

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Service Fabric

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

SignalR
NAME PA C K A GE DO C S SO URC E

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Spring Cloud

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

SQL

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

SQL Virtual Machine

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Storage

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Storage Cache

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Import/Export

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Storage Pool

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Stream Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Subscription

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Support

Resource Management - Maven 1.0.0-beta.5 docs GitHub 1.0.0-beta.5

Synapse Analytics

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

Time Series Insights

Resource Management - Maven 2.12.0 docs GitHub 2.12.0

Traffic Manager

Resource Management - Maven 1.0.0-beta.4 docs GitHub 1.0.0-beta.4

Video Analyzer

Resource Management - Maven 1.0.0-beta.3 docs GitHub 1.0.0-beta.3

VMware Solution

Resource Management - Maven 1.0.0-beta.1 docs GitHub 1.0.0-beta.1

VMware Solution by
CloudSimple

Resource Management - Maven 1.0.0-beta.2 docs GitHub 1.0.0-beta.2

Web PubSub

Session Management Maven 1.0.0-beta.1

NAME PA C K A GE DO C S SO URC E

Session Management - Maven 1.0.0-beta.1

Datastore Azure Cache For
Redis

Session Management - Maven 1.0.0-beta.1

Tomcat

SVC Management Maven 0.9.8

Azure Identity Spring Maven 1.13.0 GitHub 1.13.0

Azure Spring Boot Maven 3.13.0 GitHub 3.13.0

AutoConfigure

Azure Spring Boot BOM Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Active Directory B2C

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Cosmos

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Certificates

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Key Vault Secrets

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Service bus Jms

Azure Spring Boot Starter Maven 3.13.0 GitHub 3.13.0

Storage

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config

Azure Spring Cloud Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config
Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Autoconfigure

Azure Spring Cloud Context Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Dependencies
NAME PA C K A GE DO C S SO URC E

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management

Azure Spring Cloud Feature Maven 2.2.0 docs GitHub 2.2.0

Management Web

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Core

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Event Hubs

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Service Bus

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Storage Queue

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Integration Test

Azure Spring Cloud Maven 2.13.0 GitHub 2.13.0

Messaging

Azure Spring Cloud Starter Maven 2.3.0 docs GitHub 2.3.0

Appconfiguration Config

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Cache

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Event Hubs Kafka

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Service bus

Azure Spring Cloud Starter Maven 2.13.0 GitHub 2.13.0

Storage Queue

Azure Spring Cloud Storage Maven 2.13.0 GitHub 2.13.0

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Event Hubs

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Core

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Queue
NAME PA C K A GE DO C S SO URC E

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Service bus Topic

Azure Spring Cloud Stream Maven 2.13.0 GitHub 2.13.0

Binder Test

Azure Spring Cloud Maven 2.5.0 GitHub 2.5.0

Telemetry

Key Vault - JCA Maven 2.5.0 docs GitHub 2.5.0

Spring Data Cosmos Maven 3.18.0 docs GitHub 3.18.0