Exercice – Création de ressources Azure et d’une application Spring Java

• 10 minutes

Dans cette unité, vous allez créer une application Spring Boot de base. Vous allez utiliser Azure CLI et un environnement de développement intégré (IDE) de votre choix pour éditer le code. Utilisez un terminal de votre choix pour exécuter le code.

Préparer l’environnement de travail

Configurez des variables d’environnement en utilisant les commandes suivantes :

AZ_RESOURCE_GROUP=azure-spring-workshop
AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
AZ_LOCATION=<YOUR_AZURE_REGION>
AZ_MYSQL_USERNAME=spring
AZ_MYSQL_PASSWORD=<YOUR_MYSQL_PASSWORD>
AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

Dans votre code, remplacez les espaces réservés par les valeurs du tableau suivant. Ces valeurs sont utilisées tout au long de ce module.

Variable	Description
<YOUR_DATABASE_NAME>	Nom du serveur MySQL. Il doit être unique dans tout Azure.
<YOUR_AZURE_REGION>	Région Azure à utiliser. Vous pouvez utiliser eastus par défaut, mais nous vous recommandons d’utiliser une région proche de là où vous vous trouvez. Pour obtenir la liste complète des régions disponibles, entrez az account list-locations.
<YOUR_MYSQL_PASSWORD>	Mot de passe du serveur de base de données MySQL. Le mot de passe doit comporter au minimum huit caractères. Les caractères doivent être de 3 des catégories suivantes : Lettres majuscules de l’alphabet de l’anglais, lettres minuscules de l’alphabet de l’anglais, chiffres de 0 à 9 et caractères non alphanumériques (!, $, #, %, etc.).
<YOUR_LOCAL_IP_ADDRESS>	Adresse IP de l’ordinateur local à partir duquel vous allez exécuter votre application Spring Boot. Pour la trouver, pointez votre navigateur sur whatismyip.akamai.com.

Créez ensuite un groupe de ressources :

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

Créer une instance d’Azure Database pour MySQL

Vous allez maintenant créer un serveur MySQL managé.

Exécutez le script suivant pour créer une petite instance d’Azure Database pour MySQL. La base de données a 1 processeur et 2 Go de RAM.

az mysql 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_MYSQL_USERNAME \
    --admin-password $AZ_MYSQL_PASSWORD \
    | jq

Ce script crée un petit serveur MySQL qui utilise les variables que vous avez configurées précédemment.

Configurer une règle de pare-feu pour votre serveur MySQL

Les bases de données Azure Database pour MySQL sont sécurisées par défaut. Son pare-feu n’autorise pas les connexions entrantes. Ajoutez donc une règle de pare-feu permettant à l’adresse IP locale d’accéder au serveur de base de données.

Exécutez la commande suivante pour ouvrir le pare-feu du serveur :

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

Exécutez la commande suivante pour autoriser l’accès au pare-feu depuis des ressources Azure :

az mysql server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name allAzureIPs \
    --server-name $AZ_DATABASE_NAME \
    --start-ip-address 0.0.0.0 --end-ip-address 0.0.0.0 \
    | jq

Configurer une base de données MySQL

Le serveur MySQL que vous avez créé précédemment est vide. Il n’a aucune base de données que vous pouvez utiliser avec l’application Spring Boot. Créez une base de données nommée demo :

az mysql db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name demo \
    --server-name $AZ_DATABASE_NAME \
    | jq

Générer l’application à l’aide de Spring Initializr

Spring Initializr est une application web qui génère pour vous une structure de projet Spring Boot. Elle ne génère pas de code d’application, mais elle vous donne une structure de projet de base et une spécification de build Maven.

Vous allez générer la structure de votre application avec trois dépendances : web, mysql et data-jpa. Vous n’avez pas besoin de spécifier des dépendances Azure, car vous allez exécuter l’application localement.

À l’invite de commandes, générez l’application :

curl https://start.spring.io/starter.tgz -d type=maven-project -d dependencies=web,data-jpa,mysql -d baseDir=azure-spring-workshop -d bootVersion=3.1.5.RELEASE -d javaVersion=17 | tar -xzvf -

Configurer Spring Boot pour qu’il utilise Azure Database pour MySQL

Ouvrez le fichier src/main/resources/application.properties, puis ajoutez-y des propriétés. Veillez à remplacer les deux variables $AZ_DATABASE_NAME et la variable $AZ_MYSQL_PASSWORD par les valeurs que vous avez configurées précédemment.

logging.level.org.hibernate.SQL=DEBUG

spring.datasource.url=jdbc:mysql://$AZ_DATABASE_NAME.mysql.database.azure.com:3306/demo?serverTimezone=UTC
spring.datasource.username=spring@$AZ_DATABASE_NAME
spring.datasource.password=$AZ_MYSQL_PASSWORD

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=create-drop

Lancez maintenant votre application avec le wrapper Maven fourni :

./mvnw spring-boot:run

Cette capture d’écran montre l’application s’exécutant pour la première fois :

Coder l’application

Ajoutez ensuite le code Java suivant. Il utilise l’API de persistance Java (JPA) pour stocker et récupérer des données sur votre serveur MySQL.

Vous allez utiliser une classe d’entité JPA pour mapper directement un objet Todo Java à la table Todo de MySQL.

À côté de la classe DemoApplication, créez une classe d’entité Todo. Ensuite, ajoutez le code suivant :

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    @GeneratedValue
    private Long id;

    private String description;

    private String details;

    private boolean done;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Todo)) {
            return false;
        }
        return id != null && id.equals(((Todo) o).id);
    }

    @Override
    public int hashCode() {
        return 31;
    }
}

Cette classe est un modèle de domaine qui est mappé à la table Todo. Elle sera créée automatiquement par JPA.

Pour gérer cette classe, vous avez besoin d’un référentiel. Définissez une nouvelle interface TodoRepository dans le même package :

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface TodoRepository extends JpaRepository<Todo, Long> {
}

Il s’agit d’un référentiel JPA géré par Spring Data JPA. En étendant JpaRepository, vous bénéficiez d’une série de méthodes de création, de lecture, de mise à jour et de suppression (CRUD) génériques pour votre type. Vous pouvez ainsi effectuer des opérations comme que l’enregistrement et la suppression d’objets Todo.

Terminez l’application en créant un RestController qui peut publier des interfaces REST pour stocker et récupérer des données en utilisant HTTP. Implémentez une classe TodoController dans le même package. Ensuite, ajoutez le code suivant :

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Iterable<Todo> getTodos() {
        return todoRepository.findAll();
    }
}

Enfin, arrêtez l’application, puis redémarrez-la en utilisant la commande suivante :

./mvnw spring-boot:run

L’application Spring Boot démarre et se connecte à votre base de données.

Cette capture d’écran montre l’application qui se connecte à la base de données :

Test de l’application

Pour tester l’application, vous pouvez utiliser cURL.

Tout d’abord, créez un élément to-do (tâche) dans la base de données :

curl --header "Content-Type: application/json" \
    --request POST \
    --data '{"description":"configuration","details":"congratulations, you have set up your Spring Boot application correctly!","done": "true"}' \
    http://127.0.0.1:8080

Cette commande doit retourner l’élément créé :

{"id":1,"description":"configuration","details":"congratulations, you have set up your Spring Boot application correctly!","done":true}

Ensuite, récupérez les données en utilisant une nouvelle demande cURL :

curl http://127.0.0.1:8080

Cette commande retourne la liste des éléments to-do, y compris l’élément que vous avez créé :

[{"id":1,"description":"configuration","details":"congratulations, you have set up your Spring Boot application correctly!","done":true}]