开始使用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上