Oefening: een Java-toepassing codeeren die gebruikmaakt van geheimen

5 minuten

U gaat een Java-webtoepassing codeeren met Spring Boot die verbinding maakt met een database.

Om veiligheidsredenen moet u die databasetoegang in de toekomst beveiligen. Maar eerst gaan we de toepassingsinfrastructuur maken en vervolgens de Java-toepassing configureren voor gebruik.

De toepassingsinfrastructuur maken

In deze oefening gebruikt u Azure CLI om de volgende resources te maken:

Een Azure-resourcegroep die alle resources voor uw toepassing bevat.
Een PostgreSQL-databaseserver.
Een Azure Spring Apps-cluster en een Spring Boot-toepassing die in dit cluster wordt uitgevoerd.

U moet aan het begin van het script enkele omgevingsvariabelen opgeven die uniek moeten zijn in Azure.

U moet ook uw lokale IP-adres opgeven voor toegang tot de database vanaf uw lokale computer. Dit IP-adres moet een IPv4-adres zijn. Als u uw lokale IP-adres niet weet, kunt u naar de volgende website gaan: https://www.whatismyip.com/

Stel de volgende omgevingsvariabelen in:

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>

Zodra deze omgevingsvariabelen zijn ingesteld, kunt u de volgende opdracht uitvoeren om de resources te maken:

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

Het uitvoeren van deze opdracht kan enkele minuten in beslag nemen.

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

Het uitvoeren van deze opdracht kan enkele minuten in beslag nemen.

az extension add --name spring

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

Het uitvoeren van deze opdracht kan enkele minuten in beslag nemen.

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

Het uitvoeren van deze scripts duurt enige tijd, zodat u ze op de achtergrond kunt laten uitvoeren en de toepassing ondertussen kunt coderen.

De Java-toepassing configureren

Haal het toepassingskelet op uit de https://github.com/Azure-Samples/manage-secrets-in-java-applications GitHub-opslagplaats met behulp van de git clone opdracht:

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

Deze toepassing maakt gebruik van Spring Data JPA voor toegang tot de database. U kunt de interface van de CRUD-opslagplaats bekijken:

package com.example.demo;

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

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

Gegevens die in de database worden opgeslagen, worden vervolgens op het web weergegeven met behulp van een Spring MVC REST Controller:

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

Deze gegevens worden tijdens het opstarten in de database ingevoegd met behulp van het src/main/resources/data.sql bestand:

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

U kunt meer regels toevoegen aan dit bestand als u meer gegevens wilt of als u deze wilt aanpassen.

Voor toegang tot de database moet u het src/main/resources/application.properties bestand configureren:

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

Dit configuratiebestand heeft drie variabelen die moeten worden geconfigureerd:

${azureDatabaseName} is de naam van de PostgreSQL-database die eerder in de AZ_DATABASE_NAME omgevingsvariabele is geconfigureerd. Typ echo $AZ_DATABASE_NAME het om het te zien.
${azureDatabaseUsername} is de naam van de gebruikersnaam van de database die eerder in de AZ_DATABASE_USERNAME omgevingsvariabele is geconfigureerd. Typ echo $AZ_DATABASE_USERNAME het om het te zien.
${azureDatabasePassword} is de naam van het databasewachtwoord dat eerder in de AZ_DATABASE_PASSWORD omgevingsvariabele is geconfigureerd. Typ echo $AZ_DATABASE_PASSWORD het om het te zien.

Zoals we in de vorige les hebben gezien, is het een slechte gewoonte om deze waarden in de broncode van de toepassing te codeeren. Maar als u de toepassing wilt testen, kunt u deze tijdelijk schrijven en de toepassing uitvoeren:

./mvnw spring-boot:run

U kunt de database-inhoud lezen door toegang te krijgen tot de Spring MVC-controller met behulp van de volgende opdracht of met behulp van een webbrowser:

curl http://localhost:8080

De Java-toepassing implementeren in Azure

Als u de toepassing wilt implementeren, moet u deze eerst verpakken als jar-bestand:

./mvnw clean package

Met deze opdracht wordt een uitvoerbaar Jar-bestand in de target map gegenereerd dat u implementeert met behulp van de Azure CLI:

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

Als er fouten optreden, kunt u de toepassingslogboeken bekijken door de volgende opdracht te typen:

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

De toepassing is vervolgens beschikbaar in de cloud en u hebt toegang tot de bijbehorende gegevens met behulp van een cURL-opdracht:

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'}]
#

Gefeliciteerd U hebt een Java-toepassing gemaakt die verbinding maakt met een database. Nu moet u de databasereferenties in de volgende eenheden beveiligen.

Oefening: een Java-toepassing codeeren die gebruikmaakt van geheimen

De toepassingsinfrastructuur maken

De Java-toepassing configureren

De Java-toepassing implementeren in Azure

Feedback