Exercice - Coder une application Java qui utilise des secrets

5 minutes

Vous allez utiliser Spring Boot pour coder une application web Java qui se connecte à une base de données.

Pour des raisons de sécurité, vous devrez également sécuriser l’accès à la base de données. Mais créons l’infrastructure de l’application pour commencer, puis configurons l’application Java à utiliser.

Créer l’infrastructure de l’application

Dans cet exercice, vous utilisez Azure CLI pour créer les ressources suivantes :

Groupe de ressources Azure qui contient toutes les ressources de votre application.
Un serveur de base de données PostgreSQL.
Un cluster Azure Spring Apps et une application Spring Boot s’exécutant dans ce cluster.

Au début du script, vous devez fournir des variables d’environnement qui sont uniques dans Azure.

Vous devez également fournir votre adresse IP locale pour accéder à la base de données à partir de votre ordinateur local. Cette adresse IP doit être une adresse IPv4. Si vous ne connaissez pas votre adresse IP locale, vous pouvez accéder au site web suivant : https://www.whatismyip.com/

Définissez les variables d’environnement suivantes :

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>

Une fois ces variables d’environnement définies, vous pouvez exécuter la commande suivante pour créer les ressources :

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

Cette commande peut durer plusieurs minutes.

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

Cette commande peut durer plusieurs minutes.

az extension add --name spring

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

Cette commande peut durer plusieurs minutes.

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

Ces scripts prennent un certain temps pour s’exécuter. Vous pouvez donc les laisser s’exécuter en arrière-plan et commencer à coder l’application en attendant.

Configuration de l’application Java

Récupérez le squelette de l’application à partir du dépôt GitHub https://github.com/Azure-Samples/manage-secrets-in-java-applications avec la commande git clone :

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

Cette application utilise Spring Data JPA pour accéder à la base de données. Vous pouvez consulter l’interface du référentiel CRUD :

package com.example.demo;

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

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

Les données stockées dans la base de données sont ensuite exposées sur le web avec un contrôleur REST Spring MVC :

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

Ces données sont insérées dans la base de données au moment du démarrage à l’aide du fichier src/main/resources/data.sql :

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

Vous pouvez ajouter d’autres lignes à ce fichier si vous souhaitez davantage de données ou si vous souhaitez le personnaliser.

Pour accéder à la base de données, vous devez configurer le fichier src/main/resources/application.properties :

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

Vous devez configurer les trois variables de ce fichier de configuration :

${azureDatabaseName} est le nom de base de données PostgreSQL configuré précédemment dans la variable d’environnement AZ_DATABASE_NAME. Tapez echo $AZ_DATABASE_NAME pour le voir.
${azureDatabaseUsername} est le nom d’utilisateur de base de données configuré précédemment dans la variable d’environnement AZ_DATABASE_USERNAME. Tapez echo $AZ_DATABASE_USERNAME pour le voir.
${azureDatabasePassword} est le mot de passe de base de données configuré précédemment dans la variable d’environnement AZ_DATABASE_PASSWORD. Tapez echo $AZ_DATABASE_PASSWORD pour le voir.

Comme nous l’avons vu dans l’unité précédente, il est déconseillé de coder en dur ces valeurs dans le code source de l’application. Mais pour tester l’application, vous pouvez les écrire temporairement et exécuter l’application :

./mvnw spring-boot:run

Vous pouvez lire le contenu de la base de données en accédant au contrôleur Spring MVC avec la commande suivante ou un navigateur web :

curl http://localhost:8080

Déploiement de l’application Java dans Azure

Pour déployer l’application, vous devez d’abord la empaqueter en tant que fichier Jar :

./mvnw clean package

Cette commande produit un fichier Jar exécutable dans le répertoire target , que vous déployez à l’aide d’Azure CLI :

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

Si vous rencontrez des échecs, vous pouvez examiner les journaux d’activité de l’application en tapant la commande suivante :

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

L’application est alors disponible dans le cloud, et vous pouvez accéder à ses données avec une commande cURL:

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

Félicitations ! Vous avez créé une application Java qui se connecte à une base de données ! Vous devez maintenant sécuriser les informations d’identification de la base de données dans les unités suivantes.

Commentaires

Cette page a-t-elle été utile ?