Tutorial: Herstellen einer Verbindung mit einer verwalteten Instanz von Config Server für Spring in Azure Container Apps

Artikel
11/21/2024

Config Server für Spring bietet einen zentralen Speicherort, um Konfigurationsdaten für mehrere Anwendungen verfügbar zu machen. In diesem Artikel erfahren Sie, wie Sie eine in Azure Container Apps gehostete App mit einer Java-Instanz von Config Server für Spring verbinden.

Die Java-Komponente für Config Server für Spring verwendet ein GitHub-Repository als Quelle für Konfigurationseinstellungen. Konfigurationswerte werden Ihrer Container-App über eine Bindung zwischen der Komponente und der Container-App zur Verfügung gestellt. Wenn sich die Werte auf dem Konfigurationsserver ändern, fließen sie automatisch zu Ihrer Anwendung, ohne dass Sie die Anwendung erneut kompilieren oder erneut bereitstellen müssen.

In diesem Tutorial lernen Sie Folgendes:

Erstellen einer Java-Komponente für Config Server für Spring
Binden von Config Server für Spring an Ihre Container-App
Beobachten von Konfigurationswerten vor und nach dem Verbinden des Konfigurationsservers mit Ihrer Anwendung
Verschlüsseln und Entschlüsseln von Konfigurationswerten mit einem symmetrischen Schlüssel

Wichtig

In diesem Tutorial werden Dienste verwendet, die sich auf Ihre Azure-Rechnung auswirken können. Wenn Sie sich dafür entscheiden, Schritt für Schritt vorzugehen, sollten Sie die in diesem Artikel verwendeten Ressourcen löschen, um unerwartete Abrechnungen zu vermeiden.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Sollten Sie noch nicht über ein Konto verfügen, können Sie ein kostenloses Konto erstellen.
Azure-Befehlszeilenschnittstelle.

Überlegungen

Beachten Sie bei der Ausführung in Config Server für Spring in Azure Container Apps die folgenden Details:

Artikel	Erklärung
Umfang	Config Server für Spring wird in derselben Umgebung wie die verbundene Container-App ausgeführt.
Skalieren	Um eine einzelne Wahrheitsinstanz (Single Source Of Truth) aufrechtzuerhalten, wird Config Server für Spring nicht skaliert. Die Skalierungseigenschaften `minReplicas` und `maxReplicas` sind beide auf `1`.
Ressourcen	Die Containerressourcenzuordnung für Config Server für Spring ist fest, die Anzahl der CPU-Kerne beträgt 0,5 und die Speichergröße 1 Gi.
Preise	Die Abrechnung für Config Server für Spring erfolgt verbrauchsabhängig. Ressourcen, die von verwalteten Java-Komponenten verbraucht werden, werden in den Aktiven/Leerlaufraten abgerechnet. Sie können Komponenten löschen, die nicht mehr zum Beenden der Abrechnung verwendet werden.
Binding	Die Container-App stellt über eine Bindung eine Verbindung mit Config Server für Spring her. Die Bindung fügt Konfigurationen in Container-App-Umgebungsvariablen ein. Sobald eine Bindung eingerichtet wurde, kann die Container-App Konfigurationswerte aus Umgebungsvariablen lesen.

Setup

Bevor Sie mit Config Server für Spring arbeiten, müssen Sie zuerst die erforderlichen Ressourcen erstellen.

Azure-Befehlszeilenschnittstelle
Azure portal

Führen Sie die folgenden Befehle aus, um Ihre Ressourcengruppe und die Container Apps-Umgebung zu erstellen.

Erstellen Sie Variablen, um Ihre Anwendungskonfiguration zu unterstützen. Diese Werte werden Ihnen im Rahmen dieser Lerneinheit bereitgestellt.

export LOCATION=eastus
export RESOURCE_GROUP=my-services-resource-group
export ENVIRONMENT=my-environment
export JAVA_COMPONENT_NAME=configserver
export APP_NAME=my-config-client
export IMAGE="mcr.microsoft.com/javacomponents/samples/sample-service-config-client:latest"
export URI="https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git"

Variable	Beschreibung
`LOCATION`	Der Standort der Azure-Region, an dem Sie Ihre Container-App und die Java-Komponente erstellen
`ENVIRONMENT`	Der Name der Azure Container Apps-Umgebung für Ihre Demoanwendung.
`RESOURCE_GROUP`	Der Name der Azure-Ressourcengruppe für Ihre Demoanwendung
`JAVA_COMPONENT_NAME`	Der Name der für Ihre Container-App erstellten Java-Komponente. In diesem Fall erstellen Sie eine Java-Komponente für Config Server für Spring.
`IMAGE`	Das in Ihrer Container-App verwendete Containerimage
`URI`	Sie können den URI durch die URL zum Git-Repository ersetzen, falls er privat ist, und die zugehörigen Authentifizierungskonfigurationen wie `spring.cloud.config.server.git.username` und `spring.cloud.config.server.git.password` hinzufügen.

Melden Sie sich über die Azure-Befehlszeilenschnittstelle bei Azure an.
```
az login
```

Erstellen Sie eine Ressourcengruppe.

az group create --name $RESOURCE_GROUP --location $LOCATION

Erstellen Sie die Container Apps-Umgebung.

az containerapp env create \
    --name $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION

Führen Sie die folgenden Schritte aus, um jede der zum Erstellen einer Container-App erforderlichen Ressourcen zu erstellen.

Suchen Sie im Azure-Portal nach Container-Apps, und wählen Sie Erstellen aus.

Geben Sie auf der Registerkarte Grundeinstellungen folgende Werte ein.

Eigenschaft	Wert
Abonnement	Wählen Sie Ihr Azure-Abonnement.
Ressourcengruppe	Wählen Sie den Link Neu erstellen aus, um eine neue Ressourcengruppe namens my-resource-group zu erstellen.
Name der Container-App	Geben Sie my-config-client ein.
Bereitstellungsquelle	Wählen Sie Containerimage aus.
Region	Wählen Sie die nächstgelegene Region aus.
Container-Apps-Umgebung	Wählen Sie den Link Neu erstellen aus, um eine neue Umgebung zu erstellen.

Geben Sie im Fenster Container-Apps-Umgebung erstellen die folgenden Werte ein.

Eigenschaft Wert

Umgebungsname Geben Sie my-environment ein.

Zonenredundanz Wählen Sie Deaktiviert aus.

Wählen Sie Erstellen und dann die Registerkarte Container aus.

Eigenschaft	Wert
Umgebungsname	Geben Sie my-environment ein.
Zonenredundanz	Wählen Sie Deaktiviert aus.

Geben Sie auf der Registerkarte Container die folgenden Werte ein.

Eigenschaft	Wert
Name	Geben Sie my-config-client ein.
Bildquelle	Wählen Sie Docker Hub oder andere Registrierungen aus.
Bildtyp	Wählen Sie Öffentlich aus.
Anmeldeserver für die Registrierung	Geben Sie mcr.microsoft.com ein.
Image und Tag	Geben Sie javacomponents/samples/sample-service-config-client:latest ein.

Wählen Sie die Registerkarte Eingehend aus.

Geben Sie auf der Registerkarte Eingehend Folgendes ein, und behalten Sie für den Rest des Formulars die Standardwerte bei.

Eigenschaft	Wert
Eingehend	Wählen Sie Aktiviert.
Eingehender Datenverkehr	Wählen Sie Datenverkehr von anderen Quellen annehmen aus.
Eingangstyp	Wählen Sie HTTP aus.
Zielport	Geben Sie 8080 ein.

Klicken Sie auf Überprüfen + erstellen.

Nachdem die Validierungsprüfungen abgeschlossen sind, wählen Sie Erstellen aus, um Ihre Container-App zu erstellen.

Diese Umgebung wird verwendet, um sowohl die Java-Komponente für Config Server für Spring als auch Ihre Container-App zu hosten.

Erstellen der Java-Komponente für Config Server für Spring

Sie verfügen nun über eine Container Apps-Umgebung und können jetzt Ihre Container-App erstellen und an eine Java-Komponente für Config Server für Spring binden. Wenn Sie Ihre Container-App binden, werden Konfigurationswerte automatisch von der Config Server-Komponente mit Ihrer Anwendung synchronisiert.

Azure-Befehlszeilenschnittstelle
Azure portal

Erstellen Sie die Java-Komponente für Config Server für Spring:

az containerapp env java-component config-server-for-spring create \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 1 \
    --max-replicas 1 \
    --configuration spring.cloud.config.server.git.uri=$URI

Aktualisieren Sie die Java-Komponente für Config Server für Spring:

az containerapp env java-component config-server-for-spring update \
    --environment $ENVIRONMENT \
    --resource-group $RESOURCE_GROUP \
    --name $JAVA_COMPONENT_NAME \
    --min-replicas 2 \
    --max-replicas 2 \
    --configuration spring.cloud.config.server.git.uri=$URI spring.cloud.config.server.git.refresh-rate=60

Hier teilen Sie der Komponente über die Eigenschaft uri mit, wo sie das Repository mit Ihren Konfigurationsinformationen finden kann. Die refresh-rate-Eigenschaft teilt Container Apps mit, wie oft nach Änderungen in Ihrem Git-Repository gesucht werden soll.

Nachdem Sie nun über eine vorhandene Umgebung und eine Konfigurationsserver-Clientcontainer-App verfügen, können Sie eine Java-Komponenteninstanz von Config Server für Spring erstellen.

Wechseln Sie zur Container-Apps-Umgebung im Portal.
Wählen Sie im Navigationsmenü unter Dienste die Option Dienste aus.
Wählen Sie die Dropdownliste Konfigurieren und dann Java-Komponente aus.
Geben Sie im Bereich Java-Komponente konfigurieren die folgenden Werte ein.

Eigenschaft Wert

Java-Komponententyp Wählen Sie Config Server für Spring aus.

Java-Komponentenname Geben Sie configserver ein.
Wählen Sie im Abschnitt Git-Repositorys die Schaltfläche Hinzufügen aus, und geben Sie die folgenden Werte ein:

Eigenschaft Wert

Typ Wählen Sie HTTP aus.

URI Geben Sie https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git ein.

Übernehmen Sie bei den restlichen Feldern die Standardwerte, und wählen Sie Hinzufügen aus.
Wählen Sie Weiter aus.
Wählen Sie auf der Registerkarte Überprüfen die Option Konfigurieren aus.

Eigenschaft	Wert
Java-Komponententyp	Wählen Sie Config Server für Spring aus.
Java-Komponentenname	Geben Sie configserver ein.

Eigenschaft	Wert
Typ	Wählen Sie HTTP aus.
URI	Geben Sie https://github.com/Azure-Samples/azure-spring-cloud-config-java-aca.git ein.

Binden Ihrer Container-App an die Java-Komponente „Config Server für Spring“

Azure-Befehlszeilenschnittstelle
Azure portal

Erstellen Sie die Container-App, die Konfigurationsdaten verwendet.
```
az containerapp create \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --environment $ENVIRONMENT \
    --image $IMAGE \
    --min-replicas 1 \
    --max-replicas 1 \
    --ingress external \
    --target-port 8080 \
    --query properties.configuration.ingress.fqdn
```
Dieser Befehl gibt die URL Ihrer Container-App zurück, die Konfigurationsdaten verwendet. Kopieren Sie die URL in einen Text-Editor, damit Sie sie in einem nächsten Schritt verwenden können.

Wenn Sie Ihre App in einem Browser aufrufen, ist der zurückgegebene connectTimeout-Wert der Standardwert 0.
Erstellen Sie die Bindung mit Config Server für Spring.

Nachdem die Container-App und die Config Server-Instanz erstellt wurden, binden Sie sie zusammen mit dem Befehl update an Ihre Container-App.
```
az containerapp update \
    --name $APP_NAME \
    --resource-group $RESOURCE_GROUP \
    --bind $JAVA_COMPONENT_NAME
```
Der Parameter --bind $JAVA_COMPONENT_NAME erstellt die Verknüpfung zwischen Ihrer Container-App und der Konfigurationskomponente.

Sobald die Container-App und die Config Server-Komponente miteinander verbunden wurden, werden Konfigurationsänderungen automatisch mit der Container-App synchronisiert.

Wenn Sie die URL der App erneut aufrufen, lautet der Wert von connectTimeout jetzt 10000. Dieser Wert stammt aus dem Git-Repository, das in der Variablen $URI ursprünglich als Quelle der Konfigurationskomponente festgelegt wurde. Konkret wird dieser Wert aus der connectionTimeout-Eigenschaft in der Datei application.yml des Repositorys abgerufen.

Die Bindungsanforderung fügt die Konfigurationseinstellung als Umgebungsvariablen in die Anwendung ein. Diese Werte sind jetzt für den Anwendungscode verfügbar, der beim Abrufen von Konfigurationseinstellungen vom Konfigurationsserver verwendet werden soll.

In diesem Fall stehen der Anwendung die folgenden Umgebungsvariablen zur Verfügung:

SPRING_CLOUD_CONFIG_URI=http://[JAVA_COMPONENT_INTERNAL_FQDN]:80
SPRING_CLOUD_CONFIG_COMPONENT_URI=http://[JAVA_COMPONENT_INTERNAL_FQDN]:80
SPRING_CONFIG_IMPORT=optional:configserver:$SPRING_CLOUD_CONFIG_URI

Wenn Sie Ihr eigenes SPRING_CONFIG_IMPORT-Element anpassen möchten, können Sie auf die Umgebungsvariable SPRING_CLOUD_CONFIG_COMPONENT_URI verweisen. Beispielsweise können Sie sie durch Befehlszeilenargumente wie Java -Dspring.config.import=optional:configserver:${SPRING_CLOUD_CONFIG_COMPONENT_URI}?fail-fast=true außer Kraft setzen.

Sie können auch eine Bindung aus Ihrer Anwendung entfernen.

(Optional) Lösen Sie Ihre Container-App aus der Java-Komponente von Config Server für Spring.

Azure-Befehlszeilenschnittstelle
Azure portal

Verwenden Sie die Option --unbind, um eine Bindung aus einer Container-App zu entfernen.

az containerapp update \
    --name $APP_NAME \
    --unbind $JAVA_COMPONENT_NAME \
    --resource-group $RESOURCE_GROUP

Wenn Sie die URL der App erneut aufrufen, lautet der Wert von connectTimeout wieder 0.

Bereinigen von Ressourcen

Die in diesem Tutorial erstellten Ressourcen wirken sich auf Ihre Azure-Abrechnung aus. Führen Sie den folgenden Befehl aus, um alle in diesem Tutorial erstellten Ressourcen zu entfernen, wenn Sie diese Dienste nicht langfristig verwenden werden.

az group delete --resource-group $RESOURCE_GROUP

Konfigurationsoptionen

Der az containerapp update-Befehl verwendet den --configuration-Parameter, um zu steuern, wie der Config Server für Spring konfiguriert ist. Sie können mehrere Parameter gleichzeitig verwenden, solange sie durch ein Leerzeichen getrennt sind. Weitere Informationen finden Sie unter Spring Cloud Config Server.

In der folgenden Tabelle sind die verschiedenen verfügbaren Konfigurationswerte für Git-Back-Ends beschrieben:

Name	Beschreibung
`spring.cloud.config.server.git.uri` `spring.cloud.config.server.git.repos.{repoName}.uri`	URI des Remote-Repositorys.
`spring.cloud.config.server.git.username` `spring.cloud.config.server.git.repos.{repoName}.username`	Benutzername für die Authentifizierung beim Remote-Repository.
`spring.cloud.config.server.git.password` `spring.cloud.config.server.git.repos.{repoName}.password`	Kennwort für die Authentifizierung beim Remote-Repository.
`spring.cloud.config.server.git.search-paths` `spring.cloud.config.server.git.repos.{repoName}.search-paths`	Suchpfade, die in lokalen Arbeitskopien verwendet werden sollen. Standardmäßig wird nur der Stamm durchsucht.
`spring.cloud.config.server.git.force-pull` `spring.cloud.config.server.git.repos.{repoName}.force-pull`	Flag, die angibt, dass das Repository den Pull erzwingen soll. Bei `true` werden alle lokalen Änderungen verworfen und Werte aus dem Remoterepository übernommen.
`spring.cloud.config.server.git.default-label` `spring.cloud.config.server.git.repos.{repoName}.default-label`	Die für Git verwendete Standardbezeichnung ist main. Wenn Sie `spring.cloud.config.server.git.default-label` nicht festlegen und ein Branch mit dem Namen main nicht vorhanden ist, versucht der Konfigurationsserver standardmäßig auch, einen Branch mit dem Namen master auszuchecken. Wenn Sie das Fallbackbranch-Verhalten deaktivieren möchten, können Sie `spring.cloud.config.server.git.tryMasterBranch` auf `false` festlegen.
`spring.cloud.config.server.git.try-master-branch` `spring.cloud.config.server.git.repos.{repoName}.try-master-branch`	Der Konfigurationsserver versucht standardmäßig, einen Branch namens master auzuschecken.
`spring.cloud.config.server.git.skip-ssl-validation` `spring.cloud.config.server.git.repos.{repoName}.skip-ssl-validation`	Sie können die Überprüfung des TLS-/SSL-Zertifikats des Git-Servers auf dem Konfigurationsserver durch Festlegen der `git.skipSslValidation`-Eigenschaft auf `true` deaktivieren.
`spring.cloud.config.server.git.clone-on-start` `spring.cloud.config.server.git.repos.{repoName}.clone-on-start`	Flag, um anzugeben, dass das Repository beim Start geklont werden soll, nicht bei Bedarf. Führt im Allgemeinen zu einem langsameren Start, aber einer schnelleren ersten Abfrage.
`spring.cloud.config.server.git.timeout` `spring.cloud.config.server.git.repos.{repoName}.timeout`	Timeout in Sekunden zum Abrufen einer HTTP- oder SSH-Verbindung, falls zutreffend. Der Standardwert für beträgt 5 Sekunden.
`spring.cloud.config.server.git.refresh-rate` `spring.cloud.config.server.git.repos.{repoName}.refresh-rate`	Wie oft ruft der Konfigurationsserver aktualisierte Konfigurationsdaten aus Ihrem Git-Back-End ab.
`spring.cloud.config.server.git.private-key` `spring.cloud.config.server.git.repos.{repoName}.private-key`	Gültiger privater SSH-Schlüssel. Muss festgelegt werden, wenn `ignore-local-ssh-settings` gleich `true` ist und der Git-URI im SSH-Format vorliegt.
`spring.cloud.config.server.git.host-key` `spring.cloud.config.server.git.repos.{repoName}.host-key`	Gültiger SSH-Hostschlüssel. Muss festgelegt werden, wenn `host-key-algorithm` auch festgelegt ist.
`spring.cloud.config.server.git.host-key-algorithm` `spring.cloud.config.server.git.repos.{repoName}.host-key-algorithm`	Einer von der folgenden Werte: `ssh-dss`, `ssh-rsa`, `ssh-ed25519`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384` oder `ecdsa-sha2-nistp521`. Muss festgelegt werden, wenn `host-key` auch festgelegt ist.
`spring.cloud.config.server.git.strict-host-key-checking` `spring.cloud.config.server.git.repos.{repoName}.strict-host-key-checking`	`true` oder `false` Wenn `false`, ignorieren Sie Fehler mit Hostschlüssel.
`spring.cloud.config.server.git.repos.{repoName}`	URI des Remote-Repositorys.
`spring.cloud.config.server.git.repos.{repoName}.pattern`	Das Musterformat ist eine durch Trennzeichen getrennte Liste von `{application}/{profile}`-Namen mit Platzhaltern. Wenn `{application}/{profile}` keinem der Muster entspricht, wird der definierte Standard-URI verwendet.

In der folgenden Liste werden allgemeine Konfigurationen beschrieben:

Konfigurationen im Zusammenhang mit der Protokollierung:
- logging.level.*
- logging.group.*
- Alle anderen Konfigurationen unter dem logging.*-Namespace sollten verboten sein, z. B. das Schreiben von Protokolldateien mithilfe von logging.file.
spring.cloud.config.server.overrides
- Zusätzliche Zuordnung für eine Eigenschaftsquelle, die bedingungslos an alle Clients gesendet werden soll.
spring.cloud.config.override-none
- Sie können die Priorität aller Außerkraftsetzungen im Client so ändern, dass sie mehr wie Standardwerte sind, sodass Anwendungen ihre eigenen Werte in Umgebungsvariablen oder Systemeigenschaften bereitstellen können, indem Sie im Remoterepository das spring.cloud.config.override-none=true-Flag festlegen (der Standardwert ist „false“).
spring.cloud.config.allow-override
- Wenn Sie die Konfiguration für den ersten Bootstrap aktivieren, können Sie zulassen, dass Clientanwendungen die Konfiguration vom Konfigurationsserver außer Kraft setzen, indem Sie zwei Eigenschaften in der vom Konfigurationsserver bereitgestellten Anwendungskonfiguration platzieren.
spring.cloud.config.server.health.*
- Sie können den Integritätsindikator so konfigurieren, dass weitere Anwendungen zusammen mit benutzerdefinierten Profilen und benutzerdefinierten Bezeichnungen überprüft werden.
spring.cloud.config.server.accept-empty
- Sie können spring.cloud.config.server.accept-empty auf false festlegen, sodass der Server den HTTP-Status 404 zurückgibt, wenn die Anwendung nicht gefunden wird. Standardmäßig ist dieses Flag auf true festgelegt.
Verschlüsselung und Entschlüsselung (symmetrisch):
- encrypt.key
  - Praktisch, wenn Sie einen symmetrischen Schlüssel verwenden, da es sich um einen einzelnen zu konfigurierenden Eigenschaftswert handelt.
- spring.cloud.config.server.encrypt.enabled
  - Legen Sie diese Eigenschaft auf false fest, um die serverseitige Entschlüsselung zu deaktivieren.

Refresh

Dienste, die Eigenschaften nutzen, müssen vor dem Eintreten über eine Änderung informiert werden. Die Standardbenachrichtigungsmethode für Config Server für Spring umfasst das manuelle Auslösen des Aktualisierungsereignisses, z. B. „Aktualisierung durch Aufruf von https://<YOUR_CONFIG_CLIENT_HOST_NAME>/actuator/refresh“, was möglicherweise nicht möglich ist, wenn viele App-Instanzen vorhanden sind.

Stattdessen können Sie Werte von Config Server automatisch aktualisieren, indem Sie Änderungen in einem Aktualisierungsintervall vom Konfigurationsclient abfragen lassen. Verwenden Sie die folgenden Schritte, um Werte von Config Server automatisch zu aktualisieren:

Registrieren Sie eine geplante Aufgabe, um den Kontext in einem bestimmten Intervall zu aktualisieren, wie im folgenden Beispiel gezeigt:

@Configuration
@AutoConfigureAfter({RefreshAutoConfiguration.class, RefreshEndpointAutoConfiguration.class})
@EnableScheduling
public class ConfigClientAutoRefreshConfiguration implements SchedulingConfigurer {
    @Value("${spring.cloud.config.refresh-interval:60}")
    private long refreshInterval;
    @Value("${spring.cloud.config.auto-refresh:false}")
    private boolean autoRefresh;
    private final RefreshEndpoint refreshEndpoint;
    public ConfigClientAutoRefreshConfiguration(RefreshEndpoint refreshEndpoint) {
        this.refreshEndpoint = refreshEndpoint;
    }
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        if (autoRefresh) {
            // set minimal refresh interval to 5 seconds
            refreshInterval = Math.max(refreshInterval, 5);
            scheduledTaskRegistrar.addFixedRateTask(refreshEndpoint::refresh,  Duration.ofSeconds(refreshInterval));
        }
    }
}

Aktivieren Sie autorefresh und legen Sie das entsprechende Aktualisierungsintervall in der application.yml-Datei fest. Im folgenden Beispiel fragt der Client alle 60 Sekunden eine Konfigurationsänderung ab. Dies ist der Mindestwert, den Sie für ein Aktualisierungsintervall festlegen können.

Standardmäßig ist autorefresh auf false und refresh-interval auf 60 Sekunden festgelegt.
```
spring:
    cloud:
        config:
        auto-refresh: true
        refresh-interval: 60
management:
    endpoints:
        web:
        exposure:
            include:
            - refresh
```
Fügen Sie Ihrem Code @RefreshScope hinzu. Im folgenden Beispiel wird die Variable connectTimeout automatisch alle 60 Sekunden aktualisiert:
```
@RestController
@RefreshScope
public class HelloController {
    @Value("${timeout:4000}")
    private String connectTimeout;
}
```

Verschlüsselung und Entschlüsselung mit einem symmetrischen Schlüssel

Serverseitige Entschlüsselung

Standardmäßig ist die serverseitige Verschlüsselung aktiviert. Führen Sie die folgenden Schritte aus, um die Entschlüsselung in Ihrer Anwendung zu aktivieren:

Fügen Sie die verschlüsselte Eigenschaft in der Datei .properties in Ihrem Git-Repository hinzu.

Die Datei sollte in etwa wie das folgende Beispiel aufgebaut sein:
```
message={cipher}f43e3df3862ab196a4b367624a7d9b581e1c543610da353fbdd2477d60fb282f
```
Aktualisieren Sie die Java-Komponente für Config Server für Spring, um das Git-Repository zu verwenden, das die verschlüsselte Eigenschaft aufweist, und legen Sie den Verschlüsselungsschlüssel fest.

Bevor Sie den folgenden Befehl ausführen, ersetzen Sie von <> umgebene Platzhalter mit Ihren Werten.
```
az containerapp env java-component config-server-for-spring update \
    --environment <ENVIRONMENT_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --name <JAVA_COMPONENT_NAME> \
    --configuration spring.cloud.config.server.git.uri=<URI> encrypt.key=randomKey
```

Clientseitige Entschlüsselung

Sie können die clientseitige Entschlüsselung von Eigenschaften verwenden, indem Sie die folgenden Schritte durchführen:

Fügen Sie die verschlüsselte Eigenschaft in der Datei .properties in Ihrem Git-Repository hinzu.
Aktualisieren Sie die Java-Komponente für Config Server für Spring, um das Git-Repository zu verwenden, das die verschlüsselte Eigenschaft aufweist, und deaktivieren Sie die serverseitige Entschlüsselung.

Bevor Sie den folgenden Befehl ausführen, ersetzen Sie von <> umgebene Platzhalter mit Ihren Werten.
```
az containerapp env java-component config-server-for-spring update \
    --environment <ENVIRONMENT_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --name <JAVA_COMPONENT_NAME> \
    --configuration spring.cloud.config.server.git.uri=<URI> spring.cloud.config.server.encrypt.enabled=false
```
Fügen Sie in Ihrer Client-App den Entschlüsselungsschlüssel ENCRYPT_KEY=randomKey als Umgebungsvariable hinzu.

Wenn Sie alternativ spring-cloud-starter-bootstrap in classpath einschließen oder spring.cloud.bootstrap.enabled=true als Systemeigenschaft festlegen, legen Sie encrypt.key in bootstrap.properties fest.

Bevor Sie den folgenden Befehl ausführen, ersetzen Sie von <> umgebene Platzhalter mit Ihren Werten.
```
az containerapp update \
    --name <APP_NAME> \
    --resource-group <RESOURCE_GROUP> \
    --set-env-vars "ENCRYPT_KEY=randomKey"
```
```
encrypt:
  key: somerandomkey
```

Freigeben über