Uso dell'app della riga di comando Java per accedere a un'API con Azure ADUsing Java Command Line App To Access An API with Azure AD

Nota

Questo articolo fa parte della Guida per gli sviluppatori di Azure Active Directory.This article is part of the Azure Active Directory developer's guide.

Azure AD facilita e semplifica l'outsourcing della gestione delle identità delle app Web, fornendo un unico account di accesso e disconnessione solo con poche righe di codice.Azure AD makes it simple and straightforward to outsource your web app's identity management, providing single sign-in and sign-out with only a few lines of code. Nelle app Web Java, è possibile eseguire questa operazione utilizzando l’implementazione Microsoft di ADAL4J basato sulla community.In Java web apps, you can accomplish this using Microsoft's implementation of the community-driven ADAL4J.

ADAL4J verrà usato per:Here we'll use ADAL4J to:

  • Connettere l'utente all'app usando Azure AD come provider di identità.Sign the user into the app using Azure AD as the identity provider.
  • Visualizzare alcune informazioni relative all'utente.Display some information about the user.
  • Disconnettere l'utente dall'app.Sign the user out of the app.

A questo scopo è necessario:In order to do this, you'll need to:

  1. Registrare un'applicazione con Azure AD.Register an application with Azure AD
  2. Configurare l'app per usare la libreria ADAL per Java (ADAL4J).Set up your app to use the ADAL4J library.
  3. Usare la libreria ADAL4J per inviare le richieste di accesso e disconnessione ad Azure AD.Use the ADAL4J library to issue sign-in and sign-out requests to Azure AD.
  4. Visualizzare dati relativi all'utente.Print out data about the user.

Per iniziare, scaricare la struttura dell'app o scaricare l'esempio completato.To get started, download the app skeleton or download the completed sample. Sarà necessario anche un tenant di Azure AD in cui registrare l'applicazione.You'll also need an Azure AD tenant in which to register your application. Se non si ha già un tenant, vedere le informazioni su come ottenerne uno.If you don't have one already, learn how to get one.

1. Registrare un'applicazione con Azure AD1. Register an Application with Azure AD

Per consentire all'app di autenticare gli utenti, sarà innanzitutto necessario registrare una nuova applicazione nel tenant.To enable your app to authenticate users, you'll first need to register a new application in your tenant.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Nella barra in alto fare clic sull'account e nell'elenco Directory scegliere il tenant di Active Directory in cui si vuole registrare l'applicazione.On the top bar, click on your account and under the Directory list, choose the Active Directory tenant where you wish to register your application.
  3. Fare clic su Altri servizi nella barra di spostamento a sinistra e scegliere Azure Active Directory.Click on More Services in the left hand nav, and choose Azure Active Directory.
  4. Fare clic su App registrations (Registrazioni app) e scegliere Aggiungi.Click on App registrations and choose Add.
  5. Seguire le istruzioni e creare una nuova Applicazione Web e/o API Web.Follow the prompts and create a new Web Application and/or WebAPI.
    • Il nome dell'applicazione deve essere una descrizione per gli utenti finali.The name of the application will describe your application to end-users
    • L' URL accesso è l'URL di base dell'app.The Sign-On URL is the base URL of your app. Il valore predefinito della struttura è http://localhost:8080/adal4jsample/.The skeleton's default is http://localhost:8080/adal4jsample/.
  6. Dopo avere completato la registrazione, AAD assegnerà all'app un ID app univoco.Once you've completed registration, AAD will assign your app a unique Application ID. Poiché questo valore sarà necessario nelle sezioni successive, copiarlo dalla scheda dell'applicazione.You'll need this value in the next sections, so copy it from the application tab.
  7. Dalla pagina Impostazioni -> Proprietà dell'applicazione aggiornare l'URI dell'ID app.From the Settings -> Properties page for your application, update the App ID URI. L' URI ID app è un identificatore univoco dell'applicazione.The App ID URI is a unique identifier for your application. Per convenzione si usa https://<tenant-domain>/<app-name>, ad esempio http://localhost:8080/adal4jsample/.The convention is to use https://<tenant-domain>/<app-name>, e.g. http://localhost:8080/adal4jsample/.

Dopo aver eseguito l'accesso al portale per l'app, creare una Chiave dalla pagina Impostazioni per l'applicazione e copiarla.Once in the portal for your app create a Key from the Settings page for your application and copy it down. Verrà richiesto a breve.You will need it shortly.

2. Configurare l'app per usare la libreria ADAL4J e i prerequisiti tramite Maven2. Set up your app to use ADAL4J library and prerequisites using Maven

In questo caso, verrà configurata la libreria ADAL4J per l'uso del protocollo di autenticazione OpenID Connect.Here, we'll configure ADAL4J to use the OpenID Connect authentication protocol. La libreria ADAL4J verrà usata, tra le altre cose, per inviare le richieste di accesso e disconnessione, gestire la sessione dell'utente e ottenere informazioni sull'utente.ADAL4J will be used to issue sign-in and sign-out requests, manage the user's session, and get information about the user, amongst other things.

  • Nella directory radice del progetto aprire o creare pom.xml, individuare // TODO: provide dependencies for Maven e sostituirlo con il codice seguente:In the root directory of your project, open/create pom.xml and locate the // TODO: provide dependencies for Maven and replace with the following:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>public-client-adal4j-sample</artifactId>
    <packaging>jar</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>public-client-adal4j-sample</name>
    <url>http://maven.apache.org</url>
    <properties>
        <spring.version>3.0.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.microsoft.azure</groupId>
            <artifactId>adal4j</artifactId>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.nimbusds</groupId>
            <artifactId>oauth2-oidc-sdk</artifactId>
            <version>4.5</version>
        </dependency>
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20090211</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.5</version>
        </dependency>
</dependencies>
    <build>
        <finalName>public-client-adal4j-sample</finalName>
        <plugins>
                <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.2.1</version>
            <configuration>
                <mainClass>PublicClient</mainClass>
            </configuration>
        </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>install</id>
                        <phase>install</phase>
                        <goals>
                            <goal>sources</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
      <plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>PublicClient</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>
        </plugins>
    </build>

</project>

3. Creare il file Java PublicClient3. Create the Java PublicClient file

Come indicato sopra, verrà usata l'API Graph per ottenere i dati relativi all'utente connesso.As indicated above, we will be using the Graph API to get data about the logged in user. Per semplificare la procedura, sarà necessario creare un file per rappresentare un Oggetto directory e un singolo file per rappresentare l'Utente, affinché sia possibile usare il modello orientato a oggetti di Java.For this to be easy for us we should create both a file to represent a Directory Object and an individual file to represent the User so that the OO pattern of Java can be used.

  • Creare un file denominato DirectoryObject.java che verrà usato per archiviare i dati relativi a qualsiasi oggetto directory (sarà possibile riutilizzarlo in seguito per eventuali altre query dell'API Graph).Create a file called DirectoryObject.java which we will use to store basic data about any DirectoryObject (you can feel free to use this later for any other Graph Queries you may do). È possibile tagliare e incollare dal codice seguente:You can cut/paste this from below:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javax.naming.ServiceUnavailableException;

import com.microsoft.aad.adal4j.AuthenticationContext;
import com.microsoft.aad.adal4j.AuthenticationResult;

public class PublicClient {

    private final static String AUTHORITY = "https://login.microsoftonline.com/common/";
    private final static String CLIENT_ID = "2a4da06c-ff07-410d-af8a-542a512f5092";

    public static void main(String args[]) throws Exception {

        try (BufferedReader br = new BufferedReader(new InputStreamReader(
                System.in))) {
            System.out.print("Enter username: ");
            String username = br.readLine();
            System.out.print("Enter password: ");
            String password = br.readLine();

            AuthenticationResult result = getAccessTokenFromUserCredentials(
                    username, password);
            System.out.println("Access Token - " + result.getAccessToken());
            System.out.println("Refresh Token - " + result.getRefreshToken());
            System.out.println("ID Token - " + result.getIdToken());
        }
    }

    private static AuthenticationResult getAccessTokenFromUserCredentials(
            String username, String password) throws Exception {
        AuthenticationContext context = null;
        AuthenticationResult result = null;
        ExecutorService service = null;
        try {
            service = Executors.newFixedThreadPool(1);
            context = new AuthenticationContext(AUTHORITY, false, service);
            Future<AuthenticationResult> future = context.acquireToken(
                    "https://graph.windows.net", CLIENT_ID, username, password,
                    null);
            result = future.get();
        } finally {
            service.shutdown();
        }

        if (result == null) {
            throw new ServiceUnavailableException(
                    "authentication result was null");
        }
        return result;
    }
}

Compilare ed eseguire l'esempioCompile and run the sample

Passare alla directory radice ed eseguire il comando seguente per compilare l'esempio appena creato con maven.Change back out to your root directory and run the following command to build the sample you just put together using maven. Verrà usato il file pom.xml scritto per le dipendenze.This will use the pom.xml file you wrote for dependencies.

$ mvn package

Nella directory /targets dovrebbe essere presente un file adal4jsample.war.You should now have a adal4jsample.war file in your /targets directory. È possibile eseguire la distribuzione nel contenitore Tomcat e visitare l'URLYou may deploy that in your Tomcat container and visit the URL

http://localhost:8080/adal4jsample/

Nota

La distribuzione di un file WAR con i server Tomcat più recenti è un'operazione semplice.It is very easy to deploy a WAR with the latest Tomcat servers. È sufficiente passare a http://localhost:8080/manager/ e seguire le istruzioni per caricare il file "adal4jsample.war".Simply navigate to http://localhost:8080/manager/ and follow the instructions on uploading your `adal4jsample.war\ file. Verrà eseguita la distribuzione automatica con l'endpoint corretto.It will autodeploy for you with the correct endpoint.

Passaggi successiviNext Steps

Congratulazioni.Congratulations! È stata compilata un'applicazione Java funzionante che può autenticare gli utenti, chiamare in modo sicuro le API Web usando OAuth 2.0 e ottenere informazioni di base sull'utente.You now have a working Java application that has the ability to authenticate users, securely call Web APIs using OAuth 2.0, and get basic information about the user. Se non si è ancora popolato il tenant con alcuni utenti, ora è possibile farlo.If you haven't already, now is the time to populate your tenant with some users.

Come riferimento, l'esempio completato (senza i valori di configurazione) è disponibile in un file con estensione .zip qui. In alternativa, è possibile clonarlo da GitHub:For reference, the completed sample (without your configuration values) is provided as a .zip here, or you can clone it from GitHub:

git clone --branch complete https://github.com/Azure-Samples/active-directory-java-webapp-openidconnect.git