Guida introduttiva: Creare un'app Java Spring con configurazione app Azure

Articolo
12/12/2024

In questa guida di avvio rapido si incorpora Configurazione app di Azure in un'app Java Spring per centralizzare l'archiviazione e la gestione delle impostazioni dell'applicazione separatamente dal codice.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Crearne una gratuitamente.
Un Archivio di configurazione app. Creare un archivio.
Java Development Kit (JDK) versione 11 supportato.
Apache Maven versione 3.0 o successive.
Applicazione Spring Boot. Se non è disponibile, creare un progetto Maven con Spring Initializr. Assicurarsi di selezionare Progetto Maven e, in Dipendenze, aggiungere la dipendenza Spring Web e quindi selezionare Java versione 8 o successiva.

Aggiungere un valore chiave

Aggiungere il valore chiave seguente all’archivio di Configurazione app e lasciare Etichetta e Tipo di contenuto con i valori predefiniti. Per altre informazioni su come aggiungere valori chiave a un archivio usando il portale di Azure o l’interfaccia della riga di comando, andare a Creare un valore chiave.

Chiave	valore
/application/config.message	Ciao

Connettersi a un archivio di Configurazione app

Ora che si dispone di un archivio Configurazione app, è possibile usare spring cloud Azure Config starter per comunicare con l'applicazione con l'archivio Configurazione app creato.

Per installare il modulo di avvio di Configurazione di Azure Spring Cloud, aggiungere la dipendenza seguente al file di pom.xml :

<dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-appconfiguration-config-web</artifactId>
</dependency>

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

Codice dell'applicazione

Per usare Spring Cloud Azure Config Starter per fare in modo che l'applicazione comunichi con l'archivio Configurazione app creato, configurare l'applicazione seguendo questa procedura.

Creare un nuovo file Java denominato MyProperties.java e aggiungere le righe seguenti:

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "config")
public class MyProperties {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

Creare un nuovo file Java denominato HelloController.java e aggiungere le righe seguenti:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    private final MyProperties properties;

    public HelloController(MyProperties properties) {
        this.properties = properties;
    }

    @GetMapping
    public String getMessage() {
        return "Message: " + properties.getMessage();
    }
}

Nel file Java dell'applicazione principale aggiungere @EnableConfigurationProperties per abilitare la classe delle proprietà di configurazione MyProperties.java per renderla effettiva e registrarla con il contenitore Spring.

import org.springframework.boot.context.properties.EnableConfigurationProperties;

@SpringBootApplication
@EnableConfigurationProperties(MyProperties.class)
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Usare per eseguire l'autenticazione DefaultAzureCredential nell'archivio Configurazione app. Seguire le istruzioni per assegnare le credenziali al ruolo lettore dati Configurazione app. Assicurarsi di consentire tempo sufficiente per la propagazione dell'autorizzazione prima di eseguire l'applicazione. Creare un nuovo file denominato AppConfigCredential.java e aggiungere le righe seguenti:

import org.springframework.stereotype.Component;

import com.azure.data.appconfiguration.ConfigurationClientBuilder;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.spring.cloud.appconfiguration.config.ConfigurationClientCustomizer;

@Component
public class AppConfigCredential implements ConfigurationClientCustomizer {

    @Override
    public void customize(ConfigurationClientBuilder builder, String endpoint) {
        builder.credential(new DefaultAzureCredentialBuilder().build());
    }
}

Creare quindi una configurazione di Bootstrap Configuration, creando spring.factories il file nella resources/META-INF directory e aggiungendo le righe seguenti e aggiornando com.example.MyApplication con il nome e il pacchetto dell'applicazione:
```
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.example.MyApplication
```

Aprire lo unit test generato automaticamente e aggiornarlo per disabilitare app Azure Configurazione oppure tenta di caricare dal servizio durante l'esecuzione di unit test.

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(properties = "spring.cloud.azure.appconfiguration.enabled=false")
class DemoApplicationTests {

    @Test
    void contextLoads() {
    }

}

Creare un nuovo file denominato bootstrap.properties nella directory resources dell'app e aggiungere la riga seguente al file.
```
spring.cloud.azure.appconfiguration.stores[0].endpoint= ${APP_CONFIGURATION_ENDPOINT}
```
Impostare una variabile di ambiente denominata APP_CONFIGURATION_ENDPOINT e impostarla sulla chiave di accesso all'archivio Configurazione app. Al prompt dei comandi eseguire questo comando e riavviare il prompt per rendere effettiva la modifica:
```
setx APP_CONFIGURATION_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Se si usa Windows PowerShell, eseguire il comando seguente:
```
$Env:APP_CONFIGURATION_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Se si usa macOS o Linux, eseguire il comando seguente:
```
export APP_CONFIGURATION_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```

Compilare ed eseguire l'app in locale

Aprire il prompt dei comandi alla directory radice ed eseguire i comandi seguenti per compilare l'applicazione Spring Boot con Maven ed eseguirla.
```
mvn clean package
mvn spring-boot:run
```
Quando l'applicazione è in esecuzione, è possibile testarla usando curl, ad esempio:
```
curl -X GET http://localhost:8080/
```
Dovrebbe essere visualizzato il messaggio indicante che è stato eseguito l'accesso nell'archivio di Configurazione app.

Pulire le risorse

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Nella casella Filtra per nome immettere il nome del gruppo di risorse.
Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
Selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

In questa guida di avvio rapido è stato creato un nuovo archivio di Configurazione app, che è stato usato con un'app Java Spring. Per altre informazioni, vedere Spring in Azure. Per altre domande, vedere la documentazione di riferimento, con tutti i dettagli sul funzionamento della libreria spring cloud app Azure Configuration. Per informazioni su come abilitare l'app Java Spring per aggiornare in modo dinamico le impostazioni di configurazione, continuare con l'esercitazione successiva.

Abilitare la configurazione dinamica

Condividi tramite