Een Spring Boot-microservice bouwen

  • 10 minuten

In deze module bouwen we een Spring Boot-microservice in de cloud. Het maakt gebruik van een Spring Cloud-serviceregister en een Spring Cloud-configuratieserver, die zowel worden beheerd als ondersteund door Azure Spring Apps.

Deze microservice maakt gebruik van Spring Data JPA voor het lezen en schrijven van gegevens uit een Azure-database voor MySQL-database :

  • Azure Spring Apps verbindt die database automatisch met onze service.
  • Azure Database for MySQL is een volledig beheerde versie van MySQL die wordt uitgevoerd in Azure.

De toepassing maken in Azure Spring Apps

Maak een specifieke todo-service toepassing in uw Azure Spring Apps-exemplaar:

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

Een MySQL-database maken

Maak nu een Azure Database for MySQL-database:

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"

Deze bewerking kan enkele minuten duren en voert een JSON-document uit: kopieer het wachtwoordkenmerk in dat document, omdat we dit later gaan gebruiken.

Maak nu een todos-database op die server en open de firewall zodat Azure Spring Apps er toegang toe heeft:

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"

Zodra deze bewerking is voltooid, kunt u zien wat er is gemaakt in de resourcegroep die u hebt gemaakt voor deze workshop.

De MySQL-database binden aan de app

Azure Spring Apps kan de MySQL-database die we hebben gemaakt, automatisch binden aan onze microservice.

  1. Navigeer naar uw Azure Spring Apps-exemplaar.

  2. Selecteer Apps.

  3. Selecteer de toepassing todo-service.

  4. Selecteer Serviceconnector en kies vervolgens + Maken.

    1. Voor servicetype selecteert u DB for MySQL enkele server.
    2. Geef een verbindingsnaam op, bijvoorbeeld mysql_todos.
    3. Controleer of het juiste abonnement wordt weergegeven.
    4. Kies de MySQL-server die u in de vorige stappen hebt gemaakt.
    5. Selecteer de MySQL-database die u eerder hebt gemaakt.
    6. Selecteer SpringBoot als clienttype.
    7. Selecteer de knop Volgende: Verificatie .

  5. Controleer op de pagina Verificatie of de verbindingsreeks is geselecteerd.

  6. Selecteer Doorgaan met... Databasereferenties en vul de velden gebruikersnaam en wachtwoord in. De gebruikersnaam is spring en het wachtwoord is het wachtwoordkenmerk dat we eerder hebben gekopieerd.

    Notitie

    Als u uw wachtwoord bent vergeten, kunt u het opnieuw instellen met behulp van az mysql server update -n ${SPRING_CLOUD_NAME}-mysql -g "$RESOURCE_GROUP_NAME" -p <new-password>

  7. Controleer of firewallregels configureren om toegang tot de doelservice in te schakelen is geselecteerd.

  8. Klik op Volgende: Controleren en maken.

  9. Nadat het bericht Validatie is geslaagd , selecteert u de knop Maken om de serviceconnector te maken.

Een Spring Boot-microservice maken

Nu we het Azure Spring Apps-exemplaar hebben ingericht en de servicebinding hebben geconfigureerd, gaan we de code voorbereiden todo-service .

Als u onze microservice wilt maken, gebruiken https://start.spring.io we deze met de opdrachtregel:

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 -

Notitie

We gebruiken de Spring Web, MySQL Driver, , Spring Data JPAen Eureka Discovery Clientde Config Client onderdelen.

Spring-code toevoegen om gegevens te beheren met Spring Data JPA

Maak naast de klasse DemoApplication een JPA-entiteit 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;
    }
}

Maak vervolgens een Spring Data JPA-opslagplaats om deze entiteit met de naam TodoRepository te beheren:

package com.example.demo;

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

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

En voltooi het coderen van deze toepassing door een Spring MVC-controller met de naam TodoController toe te voegen:

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

Spring Boot configureren om de databasetabellen te maken

Om de databasetabellen automatisch te genereren wanneer de app wordt geïmplementeerd, voegt u deze regel toe aan het configuratiebestand src/main/resources/application.properties:

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

De toepassing implementeren

U kunt nu uw todo-serviceproject bouwen en verzenden naar 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 ..

Als u de logboeken van de toepassing wilt controleren, voor het geval iets mislukt, kunt u de opdracht az spring app logs gebruiken:

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

Het project testen in de cloud

Nu de toepassing is geïmplementeerd, is het tijd om deze te testen!

  1. Ga in Azure Portal naar Apps in uw Azure Spring Apps-exemplaar.
    1. Controleer of de todo-service de registratiestatus 0/1 heeft. Deze informatie laat zien dat deze correct is geregistreerd in het Spring Cloud-serviceregister.
    2. Selecteer todo-service voor meer informatie over de microservice.
  2. Kopieer/plak het 'testeindpunt' dat wordt gegeven.

U kunt nu cURL gebruiken om het eindpunt te testen. De testopdracht moet er als volgt uitzien:

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

En het resultaat van deze opdracht moeten de drie items zijn die eerder zijn ingevoegd in de MySQL-database:

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