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