开始使用Quarkus – 建立PetClinic REST API（详细指南）-六虎

Quarkus –为OpenJDK HotSpot和GraalVM定制的Kubernetes Native Java仓库，由最佳的Java库和规范精心打造。– Quarkus是一个容器优先的结构，为快速发动时刻和低内存耗费而优化。该结构建立在许多流行的Java库之上，它供给了对构建规范REST以及反应式和音讯驱动的微服务的支撑。由于快速的发动时刻和低内存运用，Quarkus也能够用来完结无服务器环境下的功用。由于统一的装备、惊人的实时重载功用和东西支撑，Quarkus为更快地开发应用供给了许多或许性。

了解怎么开端运用Quarkus并构建一个PetClinic REST API。

这篇博文包含：

对开发环境的要求
创立新项目
运用Java 11开发、构建和运转应用程序
运用Postgres和Flyway装备数据源
带分页的CRUD服务
创立集成测验
实时重载和调试
Dockerizing应用程序（包含本地和非本地）
将应用程序布置到Elastic Beanstalk上

关于PetClinic API

我决议从头运用我在Spring Boot和Spring Data REST这篇博文中运用的PetClinic模型。

根本上，它是一个根本的CRUD服务，用于办理一个设想的PetClinic：宠物、兽医、拜访等。

先决条件

Docker

Docker将被用于运转服务本身的docker化版别，但它也将被用于运转PostgreSQL服务器。

带有GraalVM的JDK 11

PetClinic API将运用Java 11构建，因而必须装置JDK 11。为了构建本地可履行文件，必须有GraalVM 19.3以上版别，由于它是建立在OpenJDK 11之上的，这将是本教程的最佳挑选。装置（和办理多个版别的）Java SDK的最简单办法是运用SDKMAN!

了解怎么用SDKMAN！轻松地办理多个Java SDKs

为了支撑本地图像，请确保装置一切需求的依靠项。更多信息能够在GraalVM的文档中找到：https://www.graalvm.org/docs/reference-manual/native-image/

GraalVM官方文档：GraalVM官方文档: GraalVM

终端

该服务是在macOS上用iTerm2和oh-my-zsh开发的。我还运用httpie作为我的默许HTTP客户端。

IntelliJ

我喜爱的IDE是IntelliJ，我在做这个项目时运用了它。

在这篇文章中了解更多关于我在macOS上运用的东西：macOS：（Java）开发人员的根本东西

用Docker运转PostgreSQL

应用程序将连接到Postgres服务器，并依据装备文件（dev,test,prod ）应用不同的装备。关于dev 和prod 装备文件，咱们将需求运转服务器：每个服务器都有不同的数据库称号、端口和凭据。关于在测验中运用的test 装备文件，咱们将运用Testcontainers。

开发数据库

创立并运转容器

$ docker run --name petclinic-db-dev -p 5433:5432 -e POSTGRES_DB=petclinic-dev -e POSTGRES_USER=petclinic-dev -e POSTGRES_PASSWORD=petclinic-dev -d postgres:alpine

运转之前停止的容器

$ docker start petclinic-db-dev

Prod数据库

创立并运转该容器

$ docker run --name petclinic-db -p 5432:5432 -e POSTGRES_DB=petclinic -e POSTGRES_USER=petclinic -e POSTGRES_PASSWORD=petclinic -d postgres:alpine

运转曾经停止的容器

$ docker start petclinic-db

开端运转

引导应用程序

您能够在命令行中运用Maven引导应用程序，也能够运用在线生成器。在线生成器能够探索Quarkus应用程序能够采用的扩展和技能，而且不需求装置本地Maven。您能够在这儿拜访生成器：https://code.quarkus.io

构建PetClinic API服务需求以下扩展：

RESTEasy JAX-RS– 完结JAX-RS等的REST结构
RESTEasy Jackson– 对RESTEasy的Jackson序列化支撑
SmallRye OpenAPI– 用OpenAPI记录你的REST APIs – 自带Swagger UI
Hibernate ORM with Panache– 用Panache界说Hibernate ORM中的持久化模型
Hibernate Validator– 验证进入你的REST端点的数据
JDBC驱动 – PostgreSQL– PostgreSQL数据库连接器
Flyway– 处理你的数据库形式搬迁

一旦选定了依靠关系，你就能够下载压缩包，解压并开端开发服务。

下载的项目有一个规范的Maven项目布局。它包含Maven Wrapper，因而开发该项目不需求装置本地Maven。你还会留意到src/main/docker ，其中有本地和JVM镜像的Docker文件。

首要的装备文件–application.properties –坐落src/main/resources 。该文件夹还包含META-INF/resources ，用于寄存应用程序的静态资源，如index.html 文件。

在`pom.xml` 以及Docker文件中设置Java版别为11

在线生成器生成的项目默许运用Java 8，所以为了运用Java 11，需求做一些调整。

在生成项目的pom.xml ，改动Java版别：

    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>

在src/main/docker/Dockerfile.jvm 中设置ARG JAVA_PACKAGE=java-11-openjdk-headless

在开发形式下运转该项目

一旦完结修改，你就能够发动应用程序了。翻开你的终端，导航到项目的文件夹并运转以下命令：

$ ./mvnw compile quarkus:dev

留意：Quarkus有三种buit-in形式。dev,test 和prod 取决于你怎么运转应用程序。

在IntelliJ中开发

在IntelliJ中你只需翻开项目的文件夹或pom.xml 。 (File > Open)。该项目只能用Maven发动。这能够用Maven运转装备来完结，由于没有像Spring Boot那样的主类来发动应用程序。

对我来说，运用Quarkus开发时最好的体验是在IntelliJ之外的终端中运转应用程序。

调试

当Quarkus应用程序在开发形式下履行时，它开端启用调试协议（在5005端口）。要在IntelliJ中调试Quarkus应用程序，你需求经过Run > Attach to Process ，将调试器附加到一个正在运转的进程中。我在调试应用程序时没有遇到麻烦。

留意：你能够在禁用调试的情况下以开发形式运转应用程序。./mvnw quarkus:dev -Ddebug=false但说实话，我没有留意到默许情况下启用调试器的任何性能问题。

实时重载

在我看来，实时重载是Quarkus最酷的功用之一。它的作用非常好。根本上你能够在源代码中改动任何你想要的东西，履行请求，应用程序就会在一眨眼的功夫从头加载。我从头调整类和包，移动文件，增加和删除端点，一切这些都不需求从头发动。

数据源装备

一切的特点都在src/main/resources/application.properties 。

默许数据源特点 (`prod`)

quarkus.datasource.url=jdbc:postgresql://localhost:5432/petclinic
quarkus.datasource.driver=org.postgresql.Driver
quarkus.datasource.username=petclinic
quarkus.datasource.password=petclinic

开发数据源特点 (`dev`)

要设置形式（或装备文件）的特定特点，请运用%mode ：

%dev.quarkus.datasource.url=jdbc:postgresql://localhost:5433/petclinic-dev
%dev.quarkus.datasource.username=petclinic-dev
%dev.quarkus.datasource.password=petclinic-dev

测验数据源特点 (`test`)

咱们将在测验中运用Testcontainers。为了做到这一点，请将以下依靠项增加到pom.xml：


<properties>
    <testcontainers.version>1.12.5</testcontainers.version>
</properties>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers</artifactId>
    <version>${testcontainers.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>postgresql</artifactId>
    <version>${testcontainers.version}</version>
    <scope>test</scope>
</dependency>

增加以下装备特点到application.properties：

# Tests with Testcontainers
# initializes container for driver initialization
%test.quarkus.datasource.driver=org.testcontainers.jdbc.ContainerDatabaseDriver
# dialect must be set explicitly
%test.quarkus.hibernate-orm.dialect=org.hibernate.dialect.PostgreSQL9Dialect
# Testcontainers JDBC URL
%test.quarkus.datasource.url=jdbc:tc:postgresql:latest:///petclinic
%test.quarkus.datasource.username=petclinic
%test.quarkus.datasource.password=petclinic

在这篇博文中了解更多关于怎么在Quarkus测验中运用Testcontainers。运用Testcontainers和PostgreSQL的Quarkus测验

也请参见：https://quarkus.io/guides/datasource

Flyway 搬迁

为了利用Flyway，在src/main/resources 创立db/migration 文件夹，并增加你的搬迁文件。我的第一个搬迁文件叫V1.0.0__PetClinic.sql ，它包含一切的形式（DDL）和服务的样本数据。

留意：Quarkus支撑SQL导入，能够经过quarkus.hibernate-orm.sql-load-script 为每个装备文件进行装备，但我无法使其作业。见我在Github上陈述的问题：https://github.com/quarkusio/quarkus/issues/7358

另见：https://quarkus.io/guides/flyway

JPA实体

PetClinic的范畴模型相对简单，但它包含一些单向和双向的相关，以及根本的承继，这使得它比简单的Hello World那种模型好一点。

请留意，在这个比如中，JPA实体是由相应的Panache资源库直接回来JAX-RS资源的（见下文），因而实体类包含了JPA和Jackson注释的混合。

比如说：

@Entity
@Table(name = "visits")
public class Visit extends BaseEntity {
    @Column(name = "visit_date")
    @JsonFormat(pattern = "yyyy/MM/dd HH:mm")
    private LocalDateTime date;
    @NotEmpty
    @Column(name = "description")
    private String description;
    @ManyToOne
    @JoinColumn(name = "pet_id")
    private Pet pet;
    @ManyToOne
    @JoinColumn(name = "vet_id")
    private Vet vet;
    public Visit() {
        this.date = LocalDateTime.now();
    }
}
@Entity
@Table(name = "vets",
        uniqueConstraints =
        @UniqueConstraint(columnNames = {"first_name", "last_name"})
)
public class Vet extends Person {
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "vet_specialties", joinColumns = @JoinColumn(name = "vet_id"),
            inverseJoinColumns = @JoinColumn(name = "specialty_id"))
    @JsonIgnore
    private Set<Specialty> specialties;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "vet", fetch = FetchType.EAGER)
    @JsonIgnore
    private Set<Visit> visits;
}

一切的实体都坐落 pl.codeleak.samples.petclinic.model包中。

Hibernate ORM与Panache

假如你熟悉Spring，我想你已经听说过Spring Data项目了。在我看来，带有Panache的Hibernate ORM也有相似的目标：它经过消除重复和繁琐的作业来简化JPA开发。Panache支撑排序、分页、java.util.Optional 和java.utitl.stream.Stream 等。

你有两种办法来运用Panache：用PanacheEntity 创立实体或用PanacheRepository 创立资源库。我在这个项目中尝试了这两种办法，但由于实体中的一些承继问题，我决议坚持运用老式的办法。

用Hibernate ORM与Panache界说一个根本的资源库：

public class OwnerRepository implements PanacheRepository<Owner> {
    List<Owner> findByLastName(String lastName) {
        return list("lastName", lastName);
    }
}

一切的存储库都坐落 pl.codeleak.samples.petclinic.repository包中。

另见：https://quarkus.io/guides/hibernate-orm-panache

创立REST API

JAX-RS资源

Quarkus利用了RESTEasy的JAX-RS。为了创立API端点，咱们需求创立JAX-RS资源：

@Path(OwnerResource.RESOURCE_PATH)
@Produces(MediaType.APPLICATION_JSON)
public class OwnerResource {
    public static final String RESOURCE_PATH = "/owners";
    @Context
    UriInfo uriInfo;
    @Inject
    OwnerRepository ownerRepository;
    @Inject
    PetRepository petRepository;
    @GET
    public Response getAll(@BeanParam PageRequest pageRequest) {
    }
    @GET
    @Path("{id}")
    public Response getOne(@PathParam("id") Long id) {
    }
    @GET
    @Path("{id}/pets")
    public List<Pet> getPets(@PathParam("id") Long id) {
    }
    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    @Transactional
    public Response create(@Valid Owner owner) {
    }
}

依靠性注入是经过CDI – Context and Dependency Injection完结的。资源目标将由Quarkus主动装备。一切其他的依靠必须用CDI注解来装备依靠注入。

例如，资源库能够用@ApplicationScoped 注释，然后用@Inject 注入：

@ApplicationScoped
public class OwnerRepository implements PanacheRepository<Owner> {
    List<Owner> findByLastName(String lastName) {
        return list("lastName", lastName);
    }
}
@ApplicationScoped
public class PetRepository implements PanacheRepository<Pet> {
}

一切的资源都坐落 pl.codeleak.samples.petclinic.api包中。

另见：https://quarkus.io/guides/cdi-reference

分页

如前所述，Panache供给了对分页成果的支撑。咱们能够很容易地在咱们的资源中利用这一点：

@GET
public Response getAll(@BeanParam PageRequest pageRequest) {
    return Response.ok(((PanacheRepository) petRepository).findAll()
                    .page(Page.of(pageRequest.getPageNum(), pageRequest.getPageSize()))
                    .list()).build();
}

PageRequest 是一个Bean，它持有pageNum 和pageSize 查询参数：

public class PageRequest {
    @QueryParam("pageNum")
    @DefaultValue("0")
    private int pageNum;
    @QueryParam("pageSize")
    @DefaultValue("10")
    private int pageSize;
}

履行分页的请求能够经过httpie轻松完结：

$ http get :8080/owners pageNum==0 pageSize==2
HTTP/1.1 200 OK
Content-Length: 250
Content-Type: application/json
[
    {
        "address": "110 W. Liberty St.",
        "city": "Madison",
        "firstName": "George",
        "id": 1,
        "lastName": "Franklin",
        "telephone": "6085551023"
    },
    {
        "address": "638 Cardinal Ave.",
        "city": "Sun Prairie",
        "firstName": "Betty",
        "id": 2,
        "lastName": "Davis",
        "telephone": "6085551749"
    }
]

交易

在JPA中创立一个新目标需求一个活动的业务。为了将业务绑定到资源目标的当前办法上，请运用@Transactional ，否则在履行办法时将会发生异常：

@POST
@Consumes(MediaType.APPLICATION_JSON)
@Transactional
public Response create(@Valid Owner owner) {
    ownerRepository.persist(owner);
    var location = uriInfo.getAbsolutePathBuilder()
            .path("{id}")
            .resolveTemplate("id", owner.getId())
            .build();
    return Response.created(location).build();
}

运用httpie创立新资源：

$ http post :8080/owners <<< '
{
    "address": "110 W. Liberty St.",
    "city": "Madison",
    "firstName": "George",
    "lastName": "Franklin",
    "telephone": "6085551023"
}'
HTTP/1.1 201 Created
Content-Length: 0
Location: http://localhost:8080/owners/1042

验证

该项目运用了Hibernate Validator扩展。有了这个扩展，你能够运用规范的Hibernate验证注释（例如：@NotBlank ），当资源办法的输入参数被注释为@Valid ，验证将被主动触发，一个错误呼应将被回来给调用该办法的客户端。

以下请求的呼应示例：

$ http post :8080/owners <<< '{}'
HTTP/1.1 400 Bad Request
Content-Length: 626
Content-Type: application/json
validation-exception: true
{
    "classViolations": [],
    "exception": null,
    "parameterViolations": [
        {
            "constraintType": "PARAMETER",
            "message": "must not be empty",
            "path": "create.owner.address",
            "value": ""
        },
        ...
        {
            "constraintType": "PARAMETER",
            "message": "must not be empty",
            "path": "create.owner.telephone",
            "value": ""
        }
    ],
    "propertyViolations": [],
    "returnValueViolations": []
}

关于实时重载可靠性的说明：你能够对源代码进行任何修改，并运用httpie履行新的请求。应用程序会敏捷从头加载，你会当即得到成果。不需求从头发动。

另见：https://quarkus.io/guides/validation

Java 8日期和时刻支撑

java.util.time 当项目中含有RESTEasy Jackson扩展时，在JSON序列化和反序列化进程中支撑日期和时刻类型。

鄙人面的比如中，拜访日期是依照@JsonFormat 注释供给的格局进行序列化和反序列化的：

@Entity
@Table(name = "visits")
public class Visit extends BaseEntity {
    @Column(name = "visit_date")
    @JsonFormat(pattern = "yyyy/MM/dd HH:mm")
    private LocalDateTime date;
}

检查日期是怎么运用htppie进行序列化的：

$ http get :8080/visits/1
HTTP/1.1 200 OK
Content-Length: 174
Content-Type: application/json
{
    "date": "2013/01/01 00:00",
    "description": "rabies shot",
    "id": 1,
    "pet": {
        "birthDate": "2012/09/04",
        "id": 7,
        "name": "Samantha"
    },
    "vet": {
        "firstName": "Helen",
        "id": 2,
        "lastName": "Leary"
    }
}

你也能够在请求体中运用所需的日期格局存储拜访：

$ http post :8080/visits <<< ' 
{
    "date": "2020/01/01 00:00",
    "description": "lorem ipsum",
    "pet": {
        "id": 7
    },
    "vet": {
        "id": 2
    }
}'
HTTP/1.1 201 Created
Content-Length: 0
Location: http://localhost:8080/visits/1042

OpenAPI/Swagger支撑

SmallRye OpenAPI扩展担任供给API文档，SwaggerUI在开发形式下被启用。

默许的端点是：

OpenAPI文档 –/openapi
SwaggerUI –/swaggerui

另见：https://quarkus.io/guides/openapi-swaggerui

集成测验

Quarkus运用JUnit 5和RESTAssured进行集成测验。测验能够运用@QuarkusTest 注释来创立，默许情况下，它们是在test profile active下履行的：

@QuarkusTest
public class PetResourceTest {
    @Test
    public void pagedList() {
        given()
                .when().get("/pets?pageNum=0&pageSize=2")
                .then()
                .statusCode(200)
                .body(
                        "$.size()", is(2),
                        "name", containsInAnyOrder("Leo", "Basil")
                );
    }
}

Quarkus测验需求应用程序正在运转。有或许经过运用CDI@Alternate beans界说来替换测验中选定的bean。替代的bean必须放在src/test/java.

留意：由于profiles的支撑，你能够很容易地装备test profile的数据源与一个独自的数据库容器。见测验数据源特点。

另见：https://quarkus.io/guides/getting-started-testing

打包和运转应用程序

该应用程序能够被打包成./mvnw package 。

它在/target 目录中发生可履行的quarkus-petclinic-api-1.0.0-runner.jar 文件，并将依靠项复制到target/lib 目录中：

[INFO] [io.quarkus.deployment.pkg.steps.JarResultBuildStep] Building thin jar: /Users/rafal.borowiec/Projects/quarkus/quarkus-petclinic-api/target/quarkus-petclinic-api-1.0.0-runner.jar
[INFO] [io.quarkus.deployment.QuarkusAugmentor] Quarkus augmentation completed in 1888ms
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  15.868 s
[INFO] Finished at: 2020-02-23T19:18:25+01:00
[INFO] ------------------------------------------------------------------------

应用程序现在能够运用java -jar target/quarkus-petclinic-api-1.0.0-runner.jar 来运转：

2020-02-23 19:19:10,169 INFO  [io.quarkus] (main) quarkus-petclinic-api 1.0.0 (running on Quarkus 1.2.1.Final) started in 2.011s. Listening on: http://0.0.0.0:8080
2020-02-23 19:19:10,171 INFO  [io.quarkus] (main) Profile prod activated.
2020-02-23 19:19:10,171 INFO  [io.quarkus] (main) Installed features: [agroal, cdi, flyway, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, rest-client, resteasy, resteasy-jackson, smallrye-openapi]

留意:uber-jar能够用以下方法打包./mvnw clean package -DskipTests=true -Dquarkus.package.uber-jar=true

创立一个Docker容器，在JVM形式下运转该应用程序

$ ./mvnw clean package
$ docker build -f src/main/docker/Dockerfile.jvm -t quarkus/petclinic-api-jvm .
Successfully built 1a5d963fedfa
Successfully tagged quarkus/petclinic-api-jvm:latest

用Postgres数据库容器的链接来运转容器，用环境变量掩盖数据源的网址：

$ docker run -i --rm -p 8080:8080 --link petclinic-db -e QUARKUS_DATASOURCE_URL='jdbc:postgresql://petclinic-db/petclinic' quarkus/petclinic-api-jvm
2020-02-23 20:39:18,949 INFO  [io.quarkus] (main) quarkus-petclinic-api 1.0.0 (running on Quarkus 1.2.1.Final) started in 3.475s. Listening on: http://0.0.0.0:8080
2020-02-23 20:39:18,949 INFO  [io.quarkus] (main) Profile prod activated.
2020-02-23 20:39:18,949 INFO  [io.quarkus] (main) Installed features: [agroal, cdi, flyway, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, rest-client, resteasy, resteasy-jackson, smallrye-openapi

留意：petclinic-db 是这儿创立的Postgres容器的称号。Prod数据库。咱们还需求传递datasource url。阅览更多关于在运转时掩盖装备特点的信息。在运转时重写特点

创立本地可履行文件

你能够运用以下命令创立一个本地可履行文件：

$ ./mvnw package -Pnative
[INFO] [io.quarkus.deployment.pkg.steps.NativeImageBuildStep] Building native image from /Users/rafal.borowiec/Projects/quarkus/quarkus-petclinic-api/target/quarkus-petclinic-api-1.0.0-native-image-source-jar/quarkus-petclinic-api-1.0.0-runner.jar
...
[quarkus-petclinic-api-1.0.0-runner:50503]   (typeflow):  72,535.72 ms
[quarkus-petclinic-api-1.0.0-runner:50503]    (objects):  49,325.68 ms
[quarkus-petclinic-api-1.0.0-runner:50503]   (features):   3,115.04 ms
[quarkus-petclinic-api-1.0.0-runner:50503]     analysis: 135,220.10 ms
[quarkus-petclinic-api-1.0.0-runner:50503]     (clinit):   1,966.77 ms
[quarkus-petclinic-api-1.0.0-runner:50503]     universe:   6,919.51 ms
[quarkus-petclinic-api-1.0.0-runner:50503]      (parse):  13,679.33 ms
[quarkus-petclinic-api-1.0.0-runner:50503]     (inline):  18,193.40 ms
[quarkus-petclinic-api-1.0.0-runner:50503]    (compile):  70,849.75 ms
[quarkus-petclinic-api-1.0.0-runner:50503]      compile: 111,062.75 ms
[quarkus-petclinic-api-1.0.0-runner:50503]        image:   8,843.46 ms
[quarkus-petclinic-api-1.0.0-runner:50503]        write:   1,789.58 ms
[quarkus-petclinic-api-1.0.0-runner:50503]      [total]: 282,727.03 ms
[INFO] [io.quarkus.deployment.QuarkusAugmentor] Quarkus augmentation completed in 287304ms
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  04:58 min
[INFO] Finished at: 2020-02-23T19:25:10+01:00
[INFO] ------------------------------------------------------------------------

创立本地可履行文件的进程需求适当长的时刻，但值得等候它完结以检查应用程序的发动时刻：

$ ./target/quarkus-petclinic-api-1.0.0-runner
2020-02-23 19:26:03,959 INFO  [io.quarkus] (main) quarkus-petclinic-api 1.0.0 (running on Quarkus 1.2.1.Final) started in 0.066s. Listening on: http://0.0.0.0:8080
2020-02-23 19:26:03,959 INFO  [io.quarkus] (main) Profile prod activated.
2020-02-23 19:26:03,959 INFO  [io.quarkus] (main) Installed features: [agroal, cdi, flyway, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, rest-client, resteasy, resteasy-jackson, smallrye-openapi]

本地可履行文件的发动时刻为0.67秒，而JVM版别为2秒。

创立一个Docker容器，以本地形式运转应用程序

默许情况下，本地可履行文件是以你的操作系统所支撑的格局创立的。由于容器或许运用的可履行文件格局与您的操作系统发生的不一样，所以Maven构建能够从容器内部发生可履行文件：

$ ./mvnw package -Pnative -Dquarkus.native.container-build=true

要调整构建器镜像的版别，你需求设置quarkus.native.builder-image 特点：

$ ./mvnw clean package -Pnative -DskipTests=true -Dquarkus.native.container-build=true -Dquarkus.native.builder-image=quay.io/quarkus/ubi-quarkus-native-image:20.0.0-java11

现在，构建并运转该容器：

$ docker build -f src/main/docker/Dockerfile.native -t quarkus/petclinic-api .

$ docker run -i --rm -p 8080:8080 quarkus/petclinic-api

留意：更多关于构建本地可履行文件的信息能够在Quarkus文档中找到：https://quarkus.io/guides/building-native-image

布置到Elastic Beanstalk

在Elastic Beanstalk控制台创立新的应用程序

假如你还不是AWS客户，你需求创立一个AWS账户。注册后，你就能够拜访Elastic Beanstalk和其他你需求的AWS服务：

运用此链接翻开Elastic Beanstalk控制台：https://us-west-2.console.aws.amazon.com/elasticbeanstalk/home?region=us-west-2#/gettingStarted?applicationName=Pet Clinic API
关于Platform ，挑选Docker
关于Application Code ，挑选Sample Application
挑选Configure more options
- 在列表中找到Database ，然后点击Modify
- 关于Engine ，挑选postgres
- 关于Engine version ，挑选11.6
- 设置你所挑选的username 和password
- 关于Retention ，假如你不创立snaphost，就挑选Delete 。
- 点击Save 。
点击Create app

Elastic Beanstalk将为你创立具有一切必要资源（包含RDS）的示例应用程序。

一旦应用程序创立完结，你就能够看到该应用程序的链接。

预备应用程序包

./mvnw clean package assembly:single -Dquarkus.package.uber-jar=true

上面的命令创立了具有以下内容的包：

$ unzip -l target/quarkus-petclinic-api-1.0.1-eb.zip
Archive:  target/quarkus-petclinic-api-1.0.1-eb.zip
  Length      Date    Time    Name
---------  ---------- -----   ----
        0  03-15-2020 13:35   config/
     2059  03-15-2020 13:34   Dockerfile
      369  03-15-2020 13:34   config/application.properties
 38604205  03-15-2020 13:35   quarkus-petclinic-api-1.0.1-runner.jar
---------                     -------
 38606633                     4 files

上传应用程序到Elastic Beanstalk

运用Elastic Beanstalk控制台上传软件包
- 导航到console.aws.amazon.com/elasticbean…
- 导航到应用程序仪表板
- 点击Upload and Deploy
- 挑选上一步创立的包，然后点击Deploy
- 等候应用程序被布置

这就是了。假如你想知道更多的装备方法，请看我的博文。将Quarkus应用程序布置到AWS Elastic Beanstalk上

源代码

这篇文章的源代码能够在Github上找到：https://github.com/kolorobot/quarkus-petclinic-api

另见

运用Testcontainers和PostgreSQL的Quarkus测验
将Quarkus应用程序布置到AWS Elastic Beanstalk上

开始使用Quarkus – 建立PetClinic REST API（详细指南）