Snabbstart: Skapa en Java Spring-app med Azure App Configuration

Artikel
12/12/2024

I den här snabbstarten införlivar du Azure App Configuration i en Java Spring-app för att centralisera lagring och hantering av programinställningar separat från din kod.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa en kostnadsfritt.
Ett appkonfigurationsarkiv. Skapa en butik.
Ett Java Development Kit (JDK) som stöds med version 11.
Apache Maven version 3.0 eller senare.
Ett Spring Boot-program. Om du inte har ett skapar du ett Maven-projekt med Spring Initializr. Se till att välja Maven Project och under Beroenden lägger du till Spring Web-beroendet och väljer sedan Java version 8 eller senare.

Lägga till ett nyckelvärde

Lägg till följande nyckelvärde i appkonfigurationsarkivet och lämna Etikett och innehållstyp med sina standardvärden. Mer information om hur du lägger till nyckelvärden i ett arkiv med hjälp av Azure Portal eller CLI finns i Skapa ett nyckelvärde.

Tangent	Värde
/application/config.message	Hello (Hej)

Ansluta till ett appkonfigurationsarkiv

Nu när du har ett App Configuration Store kan du använda Spring Cloud Azure Config Starter för att få ditt program att kommunicera med appkonfigurationsarkivet som du skapar.

Om du vill installera Spring Cloud Azure Config Starter-modulen lägger du till följande beroende i din pom.xml-fil :

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

Koda appen

Om du vill använda Spring Cloud Azure Config Starter för att låta ditt program kommunicera med appkonfigurationsarkivet som du skapar konfigurerar du programmet med hjälp av följande steg.

Skapa en ny Java-fil med namnet MyProperties.java och lägg till följande rader:

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;
    }
}

Skapa en ny Java-fil med namnet HelloController.java och lägg till följande rader:

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();
    }
}

I huvudprogrammets Java-fil lägger du till @EnableConfigurationProperties för att aktivera klassen MyProperties.java konfigurationsegenskaper för att börja gälla och registrera den med Spring-containern.

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);
    }
}

Du använder för att autentisera DefaultAzureCredential till appkonfigurationsarkivet. Följ anvisningarna för att tilldela dina autentiseringsuppgifter rollen App Configuration Data Reader. Se till att ge tillräckligt med tid för att behörigheten ska spridas innan du kör programmet. Skapa en ny fil med namnet AppConfigCredential.java och lägg till följande rader:

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());
    }
}

Skapa sedan en konfigurationskonfiguration för Bootstrap genom att skapa spring.factories en fil under resources/META-INF katalogen och lägga till följande rader och uppdatera com.example.MyApplication med ditt programnamn och paket:
```
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.example.MyApplication
```

Öppna det automatiskt genererade enhetstestet och uppdatera för att inaktivera Azure App Configuration, eller så försöker den läsa in från tjänsten när enhetstester körs.

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() {
    }

}

Skapa en ny fil med namnet bootstrap.properties under resurskatalogen i din app och lägg till följande rad i filen.
```
spring.cloud.azure.appconfiguration.stores[0].endpoint= ${APP_CONFIGURATION_ENDPOINT}
```
Ange en miljövariabel med namnet APP_CONFIGURATION_ENDPOINT och ställ in den på åtkomstnyckeln till appkonfigurationsarkivet. På kommandoraden kör du följande kommando och startar om kommandotolken för att tillåta att ändringen börjar gälla:
```
setx APP_CONFIGURATION_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Om du använder Windows PowerShell kör du följande kommando:
```
$Env:APP_CONFIGURATION_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Om du använder macOS eller Linux kör du följande kommando:
```
export APP_CONFIGURATION_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```

Skapa och köra appen lokalt

Öppna kommandotolken till rotkatalogen och kör följande kommandon för att skapa ditt Spring Boot-program med Maven och kör det.
```
mvn clean package
mvn spring-boot:run
```
När programmet har körts använder du curl för att testa ditt program, till exempel:
```
curl -X GET http://localhost:8080/
```
Du ser meddelandet som du angav i App Configuration Store.

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure Portal och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här snabbstarten skapade du ett nytt App Configuration Store och använde det med en Java Spring-app. Mer information finns i Spring på Azure. Mer information finns i referensdokumentationen om hur Spring Cloud Azure App Configuration-biblioteket fungerar. Om du vill lära dig hur du gör så att din Java Spring-app dynamiskt uppdaterar konfigurationsinställningarna fortsätter du till nästa självstudie.

Aktivera dynamisk konfiguration

Dela via