Azure NetApp Files SDK for Java

This project demonstrates how to use a Java sample application to perform CRUD management operations for the Microsoft.NetApp resource provider.

In this sample application we perform the following operations:

• Creations
  • NetApp accounts
  • Capacity pools
  • Volumes
  • Snapshots
  • Volume from snapshot
• Updates
  • Change a capacity pool size from 4 TB to 10 TB
  • Change a volume size from 100 GB to 1 TB
  • Add a new NFS export policy to an existing volume
• Deletions
  • Snapshots
  • Volumes (including those created from snapshots)
  • Capacity pool
  • NetApp accounts

Note: The cleanup execution is commented out by default. If you want to run this end-to-end with the cleanup, simply uncomment the related lines in main.java

Most of these operations are based on an asynchronous programming model to demonstrate how to asynchronously manage Azure NetApp Files resources with Java. The exceptions are volume creation and deletion operations that are executed sequentially at the Resource Provider level; therefore, these operations are executed sequentially.

If you don't already have a Microsoft Azure subscription, you can get a FREE trial account here.

Prerequisites

1. This project is built upon Maven, which must be installed in order to run the sample. Instructions on installing Maven can be found on their website here
2. Azure subscription
3. Subscription needs to have Azure NetApp Files resource provider registered. For more information, see Register for NetApp Resource Provider.
4. Subscription needs to be whitelisted for Azure NetApp Files. For more information, see Submit a waitlist request for accessing the service.
5. Resource Group created
6. Virtual Network with a delegated subnet to Microsoft.Netapp/volumes resource. For more information, see Guidelines for Azure NetApp Files network planning.
7. For this sample console application to work, authentication is needed. We will use Service Principal based authentication

   1. Within an Azure Cloud Shell session, make sure you're logged in at the subscription where you want to be associated with the service principal by default:

      az account show

      If this is not the correct subscription, use:

      az account set -s <subscription name or id>  

   2. Create a service principal using Azure CLI:

      az ad sp create-for-rbac --sdk-auth

      Note: This command will automatically assign RBAC contributor role to the service principal at subscription level. You can narrow down the scope to the specific resource group where your tests will create the resources.

   3. Set the following environment variables from the output of the creation:

      Powershell

      $env:AZURE_SUBSCRIPTION_ID = <subscriptionId>
      $env:AZURE_CLIENT_ID = <clientId>
      $env:AZURE_CLIENT_SECRET = <clientSecret>
      $env:AZURE_TENANT_ID = <tenantId>

      Bash

      export AZURE_SUBSCRIPTION_ID=<subscriptionId>
      export AZURE_CLIENT_ID=<clientId>
      export AZURE_CLIENT_SECRET=<clientSecret>
      export AZURE_TENANT_ID=<tenantId>

What does netappfiles-java-sdk-sample do?

Currently, Azure NetApp Files SDK exposes control plane management operations--CRUD operations--for its resources like NetApp accounts, capacity pools, volumes, and snapshots. We start this execution by reading a configuration file (appsettings.json). This file has two sections: the 'general' section has information about the subscription and resource group to be used. The other section, 'accounts', is the place that defines the accounts, capacity pools, and volumes. This process will create a configuration object that is used extensively throughout the code to reference the resources to be created, updated, and deleted.

Note: See Resource limits for Azure NetApp Files to understand Azure NetApp Files limits.

The SDK will then move forward to the authentication process, generating a ServiceClientCredentials (service principal) that is accepted by the AzureNetAppFilesManagementClient to create the management client, which is used to make the CRUD requests and is also used extensively throughout the code.

Then the sample will start the CRUD operations by creating the accounts, capacity pools, and volumes, in this exact sequence (see Azure NetApp Files storage hierarchy). Afterwards, a snapshot is created and following that, a new volume is created from that snapshot. After all resources have been created, the sample will perform an update to a capacity pool by increasing its size and, then it will perform updates to a volume by changing its size quota and adding an extra export policy. Finally, the cleanup process starts and removes all resources deployed by this application (provided that the appropriate code in main.java has been uncommented).

Note: This sample does not have a specific retrieve section, because we perform gets and lists operations in several places throughout the code.

How the project is structured

The following table describes all files within this solution:

\^ == src/main/java/sdk/sample

How to run the console application

1. Clone the SDK sample locally

   git clone https://github.com/Azure-Samples/netappfiles-java-sdk-sample

2. Change folder to .\netappfiles-java-sdk-sample
3. Make a copy of _sample_appsettings.json file, rename it to appsettings.json and modify its contents accordingly (at minimum all values between <> must be replaced with real values).
4. Make sure you have the environment variables previously described defined.
5. Compile the console application

   mvn clean compile

6. Run the console application

   mvn exec:java -Dexec.mainClass="sdk.sample.main"

Sample output

References

• Resource limits for Azure NetApp Files
• Azure Cloud Shell
• Azure NetApp Files documentation
• Download Azure SDKs