Créer un microservice Spring Boot

Dans ce module, nous allons créer un microservice Spring Boot compatible avec le cloud. Il utilise un registre de services Spring Cloud et un serveur de configuration Spring Cloud qui sont managés et pris en charge par Azure Spring Apps.

Ce microservice utilise Spring Data JPA pour lire et écrire des données dans une base de données Azure Database pour MySQL :

• Azure Spring Apps lie automatiquement cette base de données à notre service.
• Azure Database pour MySQL est une version complètement managée de MySQL s’exécutant sur Azure.

Créer l’application sur Azure Spring Apps

Créez une application todo-service spécifique dans votre instance Azure Spring Apps :

az spring app create --name todo-service --resource-group "$RESOURCE_GROUP_NAME" --service "$SPRING_CLOUD_NAME" --runtime-version Java_17

Créer une base de données MySQL

Créez maintenant une base de données Azure Database pour MySQL :

az mysql server create \
    --name ${SPRING_CLOUD_NAME}-mysql \
    --resource-group "$RESOURCE_GROUP_NAME" \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --admin-user "spring"

Cette opération peut prendre quelques minutes et génère un document JSON : copiez l’attribut password de ce document, car nous l’utiliserons par la suite.

À présent, créez une base de données todos dans ce serveur, puis ouvrez son pare-feu pour permettre à Azure Spring Apps d’y accéder :

az mysql db create \
    --name "todos" \
    --server-name ${SPRING_CLOUD_NAME}-mysql

az mysql server firewall-rule create \
    --name ${SPRING_CLOUD_NAME}-mysql-allow-azure-ip \
    --resource-group "$RESOURCE_GROUP_NAME" \
    --server ${SPRING_CLOUD_NAME}-mysql \
    --start-ip-address "0.0.0.0" \
    --end-ip-address "0.0.0.0"

Une fois cette opération terminée, vous pouvez voir ce qui a été créé dans le groupe de ressources que vous avez créé pour cet atelier.

Lier la base de données MySQL à l’application

Azure Spring Apps peut lier automatiquement la base de données MySQL que nous avons créée à notre microservice.

1. Accédez à votre instance Azure Spring Apps.

2. Cliquez sur Applications.

3. Sélectionnez l’application todo-service.

4. Sélectionnez Connecteur de services, puis choisissez + Créer.

   1. Pour Type de service, sélectionnez Base de données pour MySQL - serveur unique.
   2. Spécifiez un nom de connexion, par exemple mysql_todos.
   3. Vérifiez que l’abonnement approprié est affiché.
   4. Choisissez le serveur MySQL créé dans les étapes précédentes.
   5. Sélectionnez la base de données MySQL créée précédemment.
   6. Sélectionnez SpringBoot comme Type de client.
   7. Sélectionnez Suivant : Authentification.

5. Dans la page Authentification, vérifiez que l’option Chaîne de connexion est sélectionnée.

6. Sélectionnez Continuer avec...Informations d’identification de la base de données et renseignez les champs de nom d’utilisateur et de mot de passe. Le nom d’utilisateur est « spring » et le mot de passe est l’attribut password que nous avons copié précédemment.

   Remarque

   Si vous avez oublié votre mot de passe, vous pouvez le réinitialiser en utilisant az mysql server update -n ${SPRING_CLOUD_NAME}-mysql -g "$RESOURCE_GROUP_NAME" -p <new-password>

7. Vérifiez que Configurer des règles de pare-feu pour activer l’accès au service cible est sélectionné.

8. Cliquez sur le bouton Suivant : Vérifier + créer.

9. Une fois que le message Validation réussie apparaît, sélectionnez le bouton Créer pour créer le connecteur de services.

Créer un microservice Spring Boot

Maintenant que nous avons provisionné l’instance Azure Spring Apps et configuré la liaison de service, préparons le code todo-service.

Pour créer notre microservice, nous allons utiliser https://start.spring.io avec la ligne de commande :

curl https://start.spring.io/starter.tgz -d type=maven-project -d dependencies=web,mysql,data-jpa,cloud-eureka,cloud-config-client -d baseDir=todo-service -d bootVersion=3.1.5.RELEASE -d javaVersion=17 | tar -xzvf -

Ajouter du code Spring pour gérer les données avec Spring Data JPA

À côté de la classe DemoApplication, créez une entité JPA Todo :

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, boolean done) {
        this.description = description;
        this.done = done;
    }

    @Id
    @GeneratedValue
    private Long id;

    private String description;

    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 boolean isDone() {
        return done;
    }

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

Créez ensuite un référentiel Spring Data JPA pour gérer cette entité sous le nom TodoRepository :

package com.example.demo;

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

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

Terminez la programmation de cette application en ajoutant un contrôleur MVC Spring appelé TodoController :

package com.example.demo;

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

import javax.annotation.PostConstruct;
import java.util.Arrays;

@RestController
public class TodoController {

    private final TodoRepository todoRepository;

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

    @PostConstruct
    public void init() {
        todoRepository.saveAll(Arrays.asList(
                new Todo("First item", true),
                new Todo("Second item", true),
                new Todo("Third item", false)));
    }

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

Configurer Spring Boot pour créer les tables de la base de données

Pour que les tables de la base de données soient générées automatiquement pendant le déploiement de l’application, ajoutez cette ligne à votre fichier de configuration src/main/resources/application.properties :

spring.jpa.hibernate.ddl-auto=create-drop

Déployer l’application

Vous pouvez maintenant créer votre projet todo-service et l’envoyer à Azure Spring Apps :

cd todo-service
./mvnw clean package -DskipTests
az spring app deploy --name todo-service --service "$SPRING_CLOUD_NAME" --resource-group "$RESOURCE_GROUP_NAME" --artifact-path target/demo-0.0.1-SNAPSHOT.jar
cd ..

Si vous souhaitez vérifier les journaux de l’application, en cas de défaillance, vous pouvez utiliser la commande az spring app logs :

az spring app logs --name todo-service --service "$SPRING_CLOUD_NAME" --resource-group "$RESOURCE_GROUP_NAME" -f

Tester le projet dans le cloud

Maintenant que l’application est déployée, il est temps de la tester !

1. Dans le portail Azure, accédez à Applications dans votre instance Azure Spring Apps.
   1. Vérifiez que todo-service a un état d’inscription indiquant 0/1. Ces informations indiquent qu’elle est correctement inscrite au registre des services Spring Cloud.
   2. Sélectionnez todo-service pour obtenir plus d’informations sur le microservice.
2. Copiez/collez le « point de terminaison de test » fourni.

Vous pouvez maintenant utiliser cURL pour tester le point de terminaison. Votre commande de test doit ressembler à ceci :

curl https://primary:XXXXXXXXXXXXXXXXXXXXXXXXXXXXX@azure-spring-cloud-workshop.test.azuremicroservices.io/todo-service/default/

Le résultat de cette commande doit correspondre aux trois éléments qui ont été précédemment insérés dans la base de données MySQL :

[{"id":"1","description":"First item","done":true},{"id":"2","description":"Second item","done":true},{"id":"3","description":"Third item","done":false}]