Introduzione allo sviluppo cloud con Java in Azure
Questo articolo illustra come configurare un ambiente di sviluppo per lo sviluppo di Azure in Java. Si creeranno quindi alcune risorse di Azure e ci si connetterà per eseguire alcune attività di base, ad esempio caricare un file o distribuire un'applicazione Web. Al termine, si sarà pronti per iniziare a usare i servizi di Azure nelle proprie applicazioni Java.
Prerequisiti
- Un account Azure. Se non è disponibile, ottenere una versione di valutazione gratuita.
- azure Cloud Shell o 'interfaccia della riga di comando di Azure 2.0.
- Java 8, incluso in Azure Cloud Shell.
- Maven 3, incluso in Azure Cloud Shell.
Configurare l'autenticazione
L'applicazione Java deve leggere e creare autorizzazioni nella sottoscrizione di Azure per eseguire il codice di esempio in questa esercitazione. Creare un'entità servizio e configurare l'applicazione per l'esecuzione con le relative credenziali. Le entità servizio consentono di creare un account non interattivo associato all'identità a cui si concedono solo i privilegi necessari per l'esecuzione dell'app.
Creare un'entità servizio usando l'interfaccia della riga di comando di Azure 2.0e acquisire l'output:
az ad sp create-for-rbac \
--name AzureJavaTest \
--role Contributor \
--scopes /subscriptions/<your-subscription-ID>
Questo comando offre una risposta nel formato seguente:
{
"appId": "a487e0c1-82af-47d9-9a0b-af184eb87646d",
"displayName": "AzureJavaTest",
"name": "http://AzureJavaTest",
"password": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
"tenant": "tttttttt-tttt-tttt-tttt-tttttttttttt"
}
Configurare quindi le variabili di ambiente:
-
AZURE_SUBSCRIPTION_ID: usare il valore ID daaz account shownell'interfaccia della riga di comando di Azure 2.0. -
AZURE_CLIENT_ID: usare il valore appId dall'output tratto da un output dell'entità servizio. -
AZURE_CLIENT_SECRET: usare il valore di password dall'output dell'entità servizio. -
AZURE_TENANT_ID: usare il valore tenant dall'output dell'entità servizio.
Per altre opzioni di autenticazione, vedere libreria client di Azure Identity per Java.
Nota
Microsoft consiglia di usare il flusso di autenticazione più sicuro disponibile. Il flusso di autenticazione descritto in questa procedura, ad esempio per database, cache, messaggistica o servizi di intelligenza artificiale, richiede un livello di attendibilità molto elevato nell'applicazione e comporta rischi non presenti in altri flussi. Usare questo flusso solo quando le opzioni più sicure, ad esempio le identità gestite per le connessioni senza password o senza chiave, non sono valide. Per le operazioni del computer locale, preferire le identità utente per le connessioni senza password o senza chiave.
Utensili
Creare un nuovo progetto Maven
Nota
Questo articolo usa lo strumento di compilazione Maven per compilare ed eseguire il codice di esempio. Altri strumenti di compilazione, ad esempio Gradle, funzionano anche con Azure SDK per Java.
Creare un progetto Maven dalla riga di comando in una nuova directory nel sistema.
mkdir java-azure-test
cd java-azure-test
mvn archetype:generate -DgroupId=com.fabrikam -DartifactId=AzureApp \
-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
Questo passaggio crea un progetto Maven di base nella directory testAzureApp. Aggiungere le voci seguenti nel file di pom.xml del progetto per importare le librerie usate nel codice di esempio in questa esercitazione.
<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>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.33</version>
</dependency>
Aggiungere una voce build sotto l'elemento project di primo livello per usare il maven-exec-plugin per eseguire gli esempi.
maven-compiler-plugin viene usato per configurare il codice sorgente e le classi generate per Java 8.
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.0.0</version>
<configuration>
<mainClass>com.fabrikam.App</mainClass>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
Creare una macchina virtuale Linux
Creare un nuovo file denominato App.java nella directory src/main/java/com/fabrikam e incollare il blocco di codice seguente. Aggiornare le variabili userName e sshKey con valori reali per il computer. Il codice crea una nuova macchina virtuale Linux con il nome testLinuxVM nel gruppo di risorse sampleResourceGroup in esecuzione nell'area stati Uniti orientali di Azure.
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.DefaultAzureCredentialBuilder;
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 App {
public static void main(String[] args) {
final String userName = "YOUR_VM_USERNAME";
final String sshKey = "YOUR_PUBLIC_SSH_KEY";
try {
TokenCredential credential = new DefaultAzureCredentialBuilder()
.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_18_04_LTS)
.withRootUsername(userName)
.withSsh(sshKey)
.withSize(VirtualMachineSizeTypes.STANDARD_D3_V2)
.create();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
Eseguire l'esempio dalla riga di comando.
mvn compile exec:java
Nella console verranno visualizzate alcune richieste REST e risposte mentre l'SDK effettua le chiamate sottostanti all'API REST di Azure per configurare la macchina virtuale e le relative risorse. Al termine del programma, verificare la macchina virtuale nella sottoscrizione con l'interfaccia della riga di comando di Azure 2.0.
az vm list --resource-group sampleVmResourceGroup
Dopo aver verificato che il codice funziona, usare l'interfaccia della riga di comando per eliminare la macchina virtuale e le relative risorse.
az group delete --name sampleVmResourceGroup
Distribuire un'app Web da un repository GitHub
Sostituire il metodo main in App.java con quello seguente. Aggiornare la variabile appName a un valore univoco prima di eseguire il codice. Questo codice distribuisce un'applicazione Web dal ramo master in un repository GitHub pubblico in un nuovo 'app Web del servizio app di Azure in esecuzione nel piano tariffario gratuito.
public static void main(String[] args) {
try {
final String appName = "YOUR_APP_NAME";
TokenCredential credential = new DefaultAzureCredentialBuilder()
.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();
}
}
Eseguire il codice come prima di usare Maven.
mvn clean compile exec:java
Aprire un browser a cui punta l'applicazione usando l'interfaccia della riga di comando.
az webapp browse --resource-group sampleWebResourceGroup --name YOUR_APP_NAME
Rimuovere l'app Web e il piano dalla sottoscrizione dopo aver verificato la distribuzione.
az group delete --name sampleWebResourceGroup
Connettersi a un database SQL di Azure
Sostituire il metodo main corrente in App.java con il codice seguente. Impostare i valori reali per le variabili. Questo codice crea un nuovo database SQL con una regola del firewall che consente l'accesso remoto. Il codice si connette quindi a esso usando il driver JBDC del database SQL.
public static void main(String args[]) {
// Create the db using the management libraries.
try {
TokenCredential credential = new DefaultAzureCredentialBuilder()
.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.
try (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";
try (Statement createStatement = conn.createStatement()) {
createStatement.execute(createTable);
}
try (Statement insertStatement = conn.createStatement()) {
insertStatement.execute(insertValues);
}
try (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());
}
}
Eseguire l'esempio dalla riga di comando.
mvn clean compile exec:java
Pulire quindi le risorse usando l'interfaccia della riga di comando.
az group delete --name sampleSqlResourceGroup
Scrivere un BLOB in un nuovo account di archiviazione
Sostituire il metodo main corrente in App.java con il codice seguente. Questo codice crea un account di archiviazione di Azure . Il codice usa quindi le librerie di Archiviazione di Azure per Java per creare un nuovo file di testo nel cloud.
public static void main(String[] args) {
try {
TokenCredential tokenCredential = new DefaultAzureCredentialBuilder()
.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();
}
}
Eseguire l'esempio dalla riga di comando.
mvn clean compile exec:java
È possibile cercare il file di helloazure.txt nell'account di archiviazione tramite il portale di Azure o con Azure Storage Explorer.
Pulire l'account di archiviazione usando l'interfaccia della riga di comando.
az group delete --name sampleStorageResourceGroup
Esplorare altri esempi
Per altre informazioni su come usare le librerie di gestione di Azure per Java per gestire le risorse e automatizzare le attività, vedere il codice di esempio per macchine virtuali, app Webe database SQL.
Note di riferimento e versione
Per tutti i pacchetti è disponibile un di riferimento.
Ottenere assistenza e inviare commenti e suggerimenti
Inviare domande alla community su Stack Overflow. Segnalare bug e problemi aperti per Azure SDK per Java nel repository GitHub .