Übung: Programmieren einer Java-Anwendung, die Geheimnisse verwendet

5 Minuten

Sie programmieren eine Java-Webanwendung mithilfe von Spring Boot, die eine Verbindung mit einer Datenbank herstellt.

Aus Sicherheitsgründen müssen Sie den Zugriff auf diese Datenbank in Zukunft schützen. Zunächst erstellen Sie jedoch die Anwendungsinfrastruktur und konfigurieren dann die zu verwendende Java-Anwendung.

Erstellen der Anwendungsinfrastruktur

In dieser Übung verwenden Sie die Azure CLI, um die folgenden Ressourcen zu erstellen:

Eine Azure-Ressourcengruppe, die alle Ressourcen für Ihre Anwendung enthält.
einen PostgreSQL-Datenbankserver
Ein Azure Spring Apps-Cluster und eine Spring Boot-Anwendung, die in diesem Cluster ausgeführt wird.

Sie müssen am Anfang des Skripts einige Umgebungsvariablen angeben, die in Azure eindeutig sein sollten.

Sie müssen auch Ihre lokale IP-Adresse angeben, um von Ihrem lokalen Computer aus auf die Datenbank zugreifen zu können. Diese IP-Adresse sollte eine IPv4-Adresse sein. Wenn Sie Ihre lokale IP-Adresse nicht kennen, können Sie die Website https://www.whatismyip.com/ aufrufen.

Legen Sie die folgenden Umgebungsvariablen fest:

AZ_RESOURCE_GROUP=<YOUR_UNIQUE_RESOURCE_GROUP_NAME>
AZ_DATABASE_USERNAME=<YOUR_POSTGRESQL_USERNAME>
AZ_DATABASE_PASSWORD=<YOUR_POSTGRESQL_PASSWORD>
AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

Nachdem diese Umgebungsvariablen festgelegt wurden, können Sie den folgenden Befehl ausführen, um die Ressourcen zu erstellen:

AZ_LOCATION=eastus
# Must be all lowercase
AZ_SPRING_CLOUD=spring-${AZ_RESOURCE_GROUP,,}

AZ_DATABASE_NAME=pgsql-${AZ_RESOURCE_GROUP}
AZ_DATABASE_USERNAME=${AZ_DATABASE_USERNAME}

az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION

Die Ausführung dieses Befehls kann mehrere Minuten dauern.

az postgres server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --admin-user $AZ_DATABASE_USERNAME \
    --admin-password $AZ_DATABASE_PASSWORD

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-azure-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address 0.0.0.0 \
    --end-ip-address 0.0.0.0

az postgres db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name demo \
    --server-name $AZ_DATABASE_NAME

Die Ausführung dieses Befehls kann mehrere Minuten dauern.

az extension add --name spring

az spring create \
   --name $AZ_SPRING_CLOUD \
   --resource-group $AZ_RESOURCE_GROUP \
   --location $AZ_LOCATION \
   --sku Basic

Die Ausführung dieses Befehls kann mehrere Minuten dauern.

az spring app create \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application \
   --runtime-version Java_11 \
   --assign-endpoint true

Diese Skripts nehmen einige Zeit in Anspruch, damit Sie sie im Hintergrund ausführen lassen und die Anwendung in der Zwischenzeit codieren können.

Konfigurieren der Java-Anwendung

Verwenden Sie den Befehl git clone, um das Anwendungsgerüst aus dem GitHub-Repository https://github.com/Azure-Samples/manage-secrets-in-java-applications abzurufen:

git clone https://github.com/Azure-Samples/manage-secrets-in-java-applications.git

Diese Anwendung verwendet Spring Data JPA für den Zugriff auf die Datenbank. Sie können sich die CRUD Repository-Schnittstelle ansehen:

package com.example.demo;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ItemRepository extends CrudRepository<Item, Integer> {
}

In der Datenbank gespeicherte Daten werden dann mithilfe eines Spring-MVC-REST-Controllers für das Internet verfügbar gemacht:

package com.example.demo;

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

@RestController
public class ItemController {

    private final ItemRepository itemRepository;

    public ItemController(ItemRepository itemRepository) {
        this.itemRepository = itemRepository;
    }

    @GetMapping("/")
    String welcome() {
        return "Here are all the database items: " + itemRepository.findAll();
    }
}

Diese Daten werden zur Startzeit mithilfe der Datei src/main/resources/data.sql in die Datenbank eingefügt:

insert into item (details) values ('This is a item from the database');

Sie können dieser Datei weitere Zeilen hinzufügen, wenn Sie weitere Daten benötigen oder sie anpassen möchten.

Für den Zugriff auf die Datenbank müssen Sie die Datei src/main/resources/application.properties konfigurieren:

logging.level.org.springframework.jdbc.core=DEBUG

spring.datasource.url=jdbc:postgresql://${azureDatabaseName}.postgres.database.azure.com:5432/demo
spring.datasource.username=${azureDatabaseUsername}@${azureDatabaseName}
spring.datasource.password=${azureDatabasePassword}

spring.sql.init.mode=always

Diese Konfigurationsdatei enthält drei Variablen, die konfiguriert werden müssen:

${azureDatabaseName} ist der Name der PostgreSQL-Datenbank, die zuvor in der Umgebungsvariablen AZ_DATABASE_NAME konfiguriert wurde. Geben Sie echo $AZ_DATABASE_NAME ein, um diesen anzuzeigen.
${azureDatabaseUsername} ist der Datenbank-Benutzername, die zuvor in der Umgebungsvariablen AZ_DATABASE_USERNAME konfiguriert wurde. Geben Sie echo $AZ_DATABASE_USERNAME ein, um diesen anzuzeigen.
${azureDatabasePassword} ist das Datenbankkennwort, das zuvor in der Umgebungsvariablen AZ_DATABASE_PASSWORD konfiguriert wurde. Geben Sie echo $AZ_DATABASE_PASSWORD ein, um dieses anzuzeigen.

Wie in der vorherigen Lerneinheit erläutert wurde, ist es schlecht, diese Werte im Quellcode der Anwendung hartzucodieren. Um die Anwendung zu testen, können Sie sie jedoch vorübergehend einfügen und die Anwendung ausführen:

./mvnw spring-boot:run

Sie können den Datenbankinhalt lesen, indem Sie mithilfe des folgenden Befehls auf den Spring-MVC-Controller zugreifen oder einen Webbrowser verwenden:

curl http://localhost:8080

Bereitstellen der Java-Anwendung in Azure

Um die Anwendung bereitzustellen, müssen Sie sie zunächst als JAR-Datei packen:

./mvnw clean package

Mit diesem Befehl wird eine ausführbare JAR-Datei im Verzeichnis target erstellt, die Sie mithilfe der Azure CLI bereitstellen:

az spring app deploy \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application \
   --artifact-path target/*.jar

Wenn Fehler auftreten, können Sie sich die Anwendungsprotokolle ansehen, indem Sie den folgenden Befehl eingeben:

az spring app logs \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application

Die Anwendung ist dann in der Cloud verfügbar, und Sie können mithilfe eines cURL-Befehls auf ihre Daten zugreifen:

curl https://$AZ_SPRING_CLOUD-application.azuremicroservices.io

# Expected output:
#
# Here are all the database items: [Secret{Id=1, details='This is a item from the database'}]
#

Herzlichen Glückwunsch! Sie haben erfolgreich eine Java-Anwendung erstellt, die eine Verbindung mit einer Datenbank herstellt! In den nächsten Lerneinheiten müssen Sie die Datenbank-Anmeldeinformationen schützen.

Übung: Programmieren einer Java-Anwendung, die Geheimnisse verwendet

Erstellen der Anwendungsinfrastruktur

Konfigurieren der Java-Anwendung

Bereitstellen der Java-Anwendung in Azure

Feedback