Övning – Koda ett Java-program som använder hemligheter

5 minuter

Du ska koda ett Java-webbprogram med Spring Boot som ansluter till en databas.

Av säkerhetsskäl måste du skydda databasåtkomsten i framtiden. Men först ska vi skapa programinfrastrukturen och sedan konfigurera Java-programmet att använda.

Skapa programinfrastrukturen

I den här övningen använder du Azure CLI för att skapa följande resurser:

En Azure-resursgrupp som innehåller alla resurser för ditt program.
En PostgreSQL-databasserver.
Ett Azure Spring Apps-kluster och ett Spring Boot-program som körs i det här klustret.

Du måste ange vissa miljövariabler i början av skriptet som ska vara unika i Hela Azure.

Du måste också ange din lokala IP-adress för att få åtkomst till databasen från den lokala datorn. Den här IP-adressen ska vara en IPv4-adress. Om du inte känner till din lokala IP-adress kan du gå till följande webbplats: https://www.whatismyip.com/

Ange följande miljövariabler:

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>

När miljövariablerna har angetts kan du köra följande kommando för att skapa resurserna:

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

Det här kommandot kan ta flera minuter att slutföra.

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

Det här kommandot kan ta flera minuter att slutföra.

az extension add --name spring

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

Det här kommandot kan ta flera minuter att slutföra.

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

De här skripten tar lite tid att köra, så du kan låta dem köras i bakgrunden och börja koda programmet under tiden.

Konfigurera Java-programmet

Hämta programskelettet https://github.com/Azure-Samples/manage-secrets-in-java-applications från GitHub-lagringsplatsen med hjälp av git clone kommandot:

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

Det här programmet använder Spring Data JPA för att komma åt databasen. Du kan titta på CRUD-lagringsplatsens gränssnitt:

package com.example.demo;

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

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

Data som lagras i databasen exponeras sedan för webben med hjälp av en 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();
    }
}

Dessa data infogas i databasen vid start med hjälp av src/main/resources/data.sql filen:

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

Du kan lägga till fler rader i den här filen om du vill ha mer data eller om du vill anpassa den.

För att få åtkomst till databasen måste du konfigurera src/main/resources/application.properties filen:

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

Den här konfigurationsfilen har tre variabler som måste konfigureras:

${azureDatabaseName} är namnet på PostgreSQL-databasen som konfigurerades tidigare i AZ_DATABASE_NAME miljövariabeln. Skriv echo $AZ_DATABASE_NAME för att se den.
${azureDatabaseUsername} är namnet på databasanvändarnamnet som konfigurerades tidigare i AZ_DATABASE_USERNAME miljövariabeln. Skriv echo $AZ_DATABASE_USERNAME för att se den.
${azureDatabasePassword} är namnet på databaslösenordet som konfigurerades tidigare i AZ_DATABASE_PASSWORD miljövariabeln. Skriv echo $AZ_DATABASE_PASSWORD för att se den.

Som vi såg i föregående lektion är det en dålig idé att hårdkoda dessa värden i programmets källkod. Men för att testa programmet kan du skriva dem tillfälligt och köra programmet:

./mvnw spring-boot:run

Du kan läsa databasinnehållet genom att komma åt Spring MVC-styrenheten med hjälp av följande kommando eller med hjälp av en webbläsare:

curl http://localhost:8080

Distribuera Java-programmet till Azure

För att distribuera programmet måste du först paketera det som en Jar-fil:

./mvnw clean package

Det här kommandot genererar en körbar Jar-fil i target katalogen som du distribuerar med hjälp av Azure CLI:

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

Om det uppstår fel kan du titta på programloggarna genom att skriva följande kommando:

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

Programmet kommer sedan att vara tillgängligt i molnet och du kan komma åt dess data med hjälp av ett cURL-kommando:

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

Grattis! Du har skapat ett Java-program som ansluter till en databas! Nu måste du skydda databasautentiseringsuppgifterna i nästa enheter.

Feedback

Var den här sidan till hjälp?