Üdvözlet mindenkinek, itt van a harmadik poszt a Quarkusról szóló sorozatunkból!
Java-mikroszolgáltatások fejlesztésekor gyakran feltételezik, hogy és – ezek különálló és egymástól független API-k. Alapértelmezés szerint a programozók rendszerint azokat az API-kat használják, amelyekhez már hozzászoktak, mivel új keretrendszerek és futási környezetek tanulmányozása sok időt igényel. Ma megpróbáljuk megkönnyíteni néhány népszerű és bemutatjuk, hogyan lehet egyszerre használni a Spring API-t és az új hasznos funkciókat .
Ha egy kicsit bővebben kifejtjük, először megvizsgáljuk a használati területeket és a részleteket arról, hogyan támogatja a Quarkus a Spring API-kat, hogy megmutassuk a Spring-fejlesztőknek, hogyan alkalmazhatják a MicroProfile API-t a mindennapi munkájuk során. Ezután beszélni fogunk a MicroProfile API-król, amelyek hasznosak lehetnek a Spring-fejlesztők számára mikroszolgáltatások létrehozásakor.
Miért éppen a Quarkus? Először is, ez élő kódolás (live coding), tehát az összes változtatás automatikus újratöltése a MicroProfile API-ban, a Spring API-ban és más Java API-kban mindössze egy paranccsal végrehajtható: mvn quarkus:dev. Másodszor, amit a szolgáltatás Person (ez Spring, MicroProfile és JPA API-kból fordít egy bináris fájlt a GraalVM natív képének használatával) mindössze 0.055 másodperc alatt elindul, és körülbelül 90 MB-ot foglal el a memóriában (RSS) a RESTful alkalmazás végpontján. Maga a fordítás mindössze egy paranccsal hajtható végre: mvn package -Pnative.
Nem fogunk belemenni a MicroProfile részleteibe, csak annyit szeretnénk segíteni a Spring-fejlesztőknek, hogy megértsék, hogyan használhatók a Spring API-k a Quarkus-ban a MicroProfile API-kkal együtt.
Konténerek és Kubernetes
Annak érdekében, hogy ne terheljük túl ezt a cikket, itt csak a Kubernetes támogatásának magas szintű aspektusait fogjuk megvizsgálni, mivel fontos ezt érteni. A Quarkus úgy pozicionálja magát, mint a Kubernetes Java-stackje, amely minimalizálja a memóriafogyasztást és a Java-alkalmazások és szolgáltatások indítási idejét, és ezzel növeli a hoszton való elhelyezés sűrűségét, valamint csökkenti az általános költségeket.
A Quarkus szintén Kubernetes erőforrásokhoz, és ajánlja a Kubernetes és a Red Hat OpenShift platformokon való telepítést. Továbbá a Quarkus automatikusan generálja a Dockerfile.jvm (JVM csomagolás) és a Dockerfile.native (natív bináris csomagolás) fájlokat, amelyek a konténerek létrehozásához szükségesek.
Végül, orientálva a Kubernetes-t mint célkörnyezet, a Quarkus nem használ Java keretrendszereket olyan esetekben, amikor hasonló funkciókat a Kubernetes platform szintjén valósítottak meg. Az 1. táblázat tartalmazza a Kubernetes és a tipikus Java keretrendszerek funkcionális illeszkedésének térképét, amelyet a Spring fejlesztők használnak.
1. táblázat. A Java keretrendszerek és a Kubernetes funkcionális illeszkedésének térképe.
Funkció
Hagyományos Spring Boot
Kubernetes
Szolgáltatás felfedezés
Eureka
DNS
Konfiguráció
Spring Cloud Config
Config Maps / Secrets
Terheléselosztás
Ribbon (ügyfél oldalon)
Szolgáltatás, Replikációs vezérlő (szerver oldalon)
A példa kódjának lefordítása és futtatása
Ebben a cikkben hivatkozunk a , amelyben a Spring és a MicroProfile API-k közösen használatosak, és még a fenti Java osztály is. A példa kódját a parancssorból le lehet fordítani és futtatni, további részletekért lásd a README.md fájlt.
Spring Framework API-k
Dependency Injection
A Quarkus számos és Spring Dependency Injection (Spring DI) API-t támogat. Ha a MicroProfile-lal dolgozik, , akkor már jól ismeri a CDI-t. Másrészről, a Spring fejlesztők a Quarkus Extension for Spring DI API-t használhatják a Spring DI kompatibilitásának biztosításához. A támogatott Spring DI API-k használatának példái a 2. táblázatban találhatók.
A mind a CDI, mind a Spring Dependency Injection használatban van. További információkat és példákat e témában a Quarkus útmutatójában talál, amelynek neve .
2. táblázat. A támogatott Spring DI API-k használatának példái.
A támogatott Spring DI funkciók
Példák
Konstruktor injekció
public PersonSpringController(
PersonSpringRepository personRepository, // injektált
PersonSpringMPService personService) { // injektált
this.personRepository = personRepository;
this.personService = personService;
}
Mező injekció
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@Configuration
@Configuration
public class AppConfiguration {
@Bean(name = "capitalizeFunction")
public StringFunction capitalizer() {
return String::toUpperCase;
}
}
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
@Override
public String apply(String s) {
return s;
}
}
@Service
public class MessageProducer {
@Value("${greeting.message}")
String message;
public String getPrefix() {
return message;
}
}
Web keretrendszer
A MicroProfile felhasználói örömmel tapasztalják, hogy a Quarkus támogatja a JAX-RS, a MicroProfile Rest Client, a JSON-P és a JSON-B megoldásait mint alap webfejlesztési modellt. A Spring fejlesztők számára kedvező hír, hogy a Quarkus nemrégiben támogatni kezdte a Spring Web API-t, különös figyelmet fordítva a REST interfészekre. A Spring DI-hez hasonlóan a Spring Web API támogatásának fő célja, hogy a Spring fejlesztők a Spring Web API-kat a MicroProfile API-kkal együtt használhassák. A támogatott Spring Web API-k használatának példáit a 3. táblázat tartalmazza, a cikk visszautal a Quarkus útmutatójára, amelynek címe .
3. táblázat. A támogatott Spring Web API interfészek használatának példái.
Támogatott Spring Web funkciók
Példák
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (részleges)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Spring Data JPA
A MicroProfile felhasználói számára kellemes hír, hogy a Quarkus támogatja a JPA-t a Hibernate ORM segítségével. A Spring fejlesztők számára is jó hír, hogy a Quarkus támogatja a közismert Spring Data JPA annotációkat és típusokat. A támogatott Spring Data JPA API-k használati példáit a 4. táblázat tartalmazza.
A a Spring Data JPA API-k használatát, míg további információk érhetők el a Quarkus útmutatójában, amelynek címe .
4. táblázat. A támogatott Spring Data JPA API interfészek használatának példái.
Támogatott Spring Data JPA funkciók
Példák
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Az Eloquent segítségével történő megvalósítása meglehetősen egyszerű:
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Repository Fragments
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Derivált lekérdezési módszerek
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Felhasználó által definiált lekérdezések
public interface MovieRepository
extends CrudRepository {
Movie findFirstByOrderByDurationDesc();
@Query("select m from Movie m where m.rating = ?1")
Iterator findByRating(String rating);
@Query("from Movie where title = ?1")
Movie findByTitle(String title);
}
MicroProfile API interfészek
Hibatűrés (Fault tolerance)
A hibamentes architektúrák rendkívül fontosak a kaszkádos hibák megakadályozásához és megbízható mikroszolgáltatás-architektúrák létrehozásához. A Spring-fejlesztők már évek óta használják a hibamentesség érdekében a circuit-breaker-eket. . A Hystrix azonban régóta nem frissült, míg a MicroProfile hibamentes megoldásai aktívan fejlődnek és már több éves termelési tapasztalattal rendelkeznek. Ezért a Quarkusban ajánlott a MicroProfile Fault Tolerance API-k alkalmazása a szolgáltatások megbízhatóságának növelése érdekében, amelyek használatával kapcsolatos példák a 5. táblázatban találhatók. További információkat erről a Quarkus útmutatójában találhat. .
5. táblázat. A támogatott MicroProfile Fault Tolerance API-k használatának példái.
MicroProfile Fault Tolerance funkciók
Leírás
Példák
@Asynchronous
Logika végrehajtása külön szálon
@Asynchronous
@Retry
public Future getSalutation() {
...
return future;
}
@Bulkhead
A párhuzamos kérések számának korlátozása
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@CircuitBreaker
Intelligens hiba kezelés és hiba utáni helyreállítás
@CircuitBreaker(delay=500 // milliszekundum
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Fallback
Alternatív logika hívása hiba esetén
@Timeout(500) // milliszekundum
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Újrapróbálkozás hiba esetén
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Időkorlát elérési hiba esetén
@Timeout(value = 500 ) // milliszekundum
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Szolgáltatások ellenőrzése (Service Health)
A Kubernetes platformok speciális szolgáltatásokkal figyelik a konténerek állapotát. Ahhoz, hogy az alapul szolgáló platform nyomon követhesse a szolgáltatásokat, a Spring-fejlesztők általában testreszabott HealthIndicator-t és Spring Boot Actuator-t használnak. A Quarkusban ezt a MicroProfile Health segítségével lehet megtenni, amely alapértelmezés szerint élettartam-ellenőrzést (liveness check) végez, de beállítható, hogy egyidejűleg ellenőrizze az élettartamot és a készenlétet (readiness). A támogatott MicroProfile Health API-k használatának példái a 6. táblázatban találhatók, további információk pedig a Quarkus útmutatójában. .
6. táblázat. A támogatott MicroProfile Health API-k használatának példái.
MicroProfile Health funkciók
Leírás
Példák
@Liveness
A platform újraindítja a hibás konténerizált alkalmazásokat
Endpoint:
host:8080/health/live
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Readiness
A platform will not route traffic to containerized applications if they are not ready.
Endpoint:
host:8080/health/ready
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Metrikák
Applications provide metrics either for operational purposes (to monitor SLA performance indicators) or for non-operational ones (business SLA indicators). Spring developers provide metrics using Spring Boot Actuator and Micrometer. In turn, Quarkus uses MicroProfile Metrics to provide basic metrics (JVM and operating system), vendor metrics (Quarkus), and application metrics. MicroProfile Metrics requires the implementation to support output formats of JSON and OpenMetrics (Prometheus). Examples of using the MicroProfile Metrics API are presented in Table 7.
A MicroProfile Metrics are used to provide application metrics. For more details, refer to the Quarkus guide. .
Table 7. Examples of using the MicroProfile Metrics APIs.
Functions of MicroProfile Metrics
Leírás
Példák
@Counted
Indicates a counter that counts the number of calls to the annotated object.
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Indicates a gauge that counts the number of concurrent calls to the annotated object.
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Gauge
Indicates a gauge that measures the value of the annotated object.
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Metered
Indicates a meter that tracks the frequency of calls to the annotated object.
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Annotation containing metadata information when a request for metric generation or submission is received.
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Indicates a timer that tracks the duration of the annotated object.
@Timed(name = "TimedFallback",
displayName="Időzített visszaesés",
description="Visszaesési késleltetés")
public String salutationFallback() {
return fallbackSalutation;
}
Metrias végpontok (Metrics Endpoints)
Alkalmazási metrikák :8080/metrics/application
Alapmetrikák :8080/metrics/base
Szállító metrikák :8080/metrics/vendor
Összes metrika :8080/metrics
MicroProfile Rest kliens
A mikroszolgáltatások gyakran RESTful végpontokat biztosítanak, amelyek használatához megfelelő kliens API-k szükségesek. A RESTful végpontok használatához a Spring-fejlesztők általában a RestTemplate-et alkalmazzák. A Quarkus e feladat megoldására MicroProfile Rest Client API-interfészeket kínál, amelyek használatának példái a 8. táblázatban találhatók.
A A RESTful végpontok használata a MicroProfile Rest Client segítségével történik. További információk és példák találhatók a Quarkus útmutatójában. .
8. táblázat. MicroProfile Rest Client API-interfészek használatának példái.
MicroProfile Rest Client funkciói
Leírás
Példák
@RegisterRestClient
Regisztrálja a típusos Java interfészt REST kliensként.
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Megjelöli a típusos REST kliens interfész példányának befecskendezését.
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Hívás
Hívja a REST végpontot.
System.out.println(
restClient.getSalutation());
mp-rest/url
Meghatározza a REST végpontot.
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Összegzés
Ebben a blogban, amely főleg a Spring-fejlesztők számára hasznos, röviden bemutattuk, hogyan lehet a Quarkus-ban a Spring API-kat együtt használni a MicroProfile API-kkal Java mikroszolgáltatások fejlesztésére, majd azokat natív bináris kódra fordítani, ami több száz megabájt memóriát takarít meg és millisekundák alatt indul.
Ahogy már említetted, további információk találhatók a Spring és MicroProfile API-k támogatásáról, valamint sok más hasznos információ a .
Forrás: habr.com
