Review Kubernetes Native Microservices with Quarkus and MicroProfile

lybaoshepherd

New member
Kubernetes Native Microservices with Quarkus and MicroProfile

[Hạn Chế Số Lượng - Đặt Mua Ngay Để Không Bỏ Lỡ!]: (https://shorten.asia/RA4pjQD4)
** Kubernetes Microservice với Quarkus và Microprofile **

** Hashtags: ** #Quarkus #Microprofile #Kubernetes

**Giới thiệu**

Quarkus là một khung Java hiện đại, nhẹ và bản địa Kubernetes giúp bạn dễ dàng xây dựng các dịch vụ microservice.Microprofile là một tập hợp các thông số kỹ thuật xác định một cách nhất quán để xây dựng các dịch vụ vi mô với Java.Cùng nhau, Quarkus và Microprofile cho phép xây dựng các dịch vụ vi mô nhanh, có thể mở rộng và di động có thể chạy trên bất kỳ nền tảng dựa trên Kubernetes nào.

Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách xây dựng microservice bản địa Kubernetes với Quarkus và Microprofile.Chúng tôi sẽ bắt đầu bằng cách tạo một dự án Quarkus mới và sau đó thêm các phụ thuộc microprofile.Sau đó, chúng tôi sẽ viết một dịch vụ microser đơn giản để lộ API RESTful.Sau đó, chúng tôi sẽ triển khai microservice của mình đến Kubernetes và kiểm tra nó bằng công cụ dòng lệnh `kubectl`.

** Tạo một dự án Quarkus **

Để tạo một dự án Quarkus mới, chúng tôi có thể sử dụng lệnh sau:

`` `
MVN IO.Quarkus: Quarkus-Maven-Plugin: 1.13.1: Tạo \
-DprojectGroupId = org.example \
-Dprojectartifactid = Quarkus-microprofile-kubernetes \
-DclassName = org.example.quarkus.microprofile.kubernetes.greetingresource
`` `

Lệnh này sẽ tạo ra một dự án Quarkus mới với một lớp Java duy nhất có tên là `GreetingResource`.Lớp `` GreetingResource` phơi bày một API RESTful cho phép chúng tôi nhận được một thông điệp chào hỏi.

** Thêm các phụ thuộc microprofile **

Để thêm các phụ thuộc microprofile vào dự án của chúng tôi, chúng tôi có thể thêm các phụ thuộc maven sau vào tệp `pom.xml`:

`` `
<phụ thuộc>
<ProupId> IO.Quarkus </groupID>
<PartifactId> Quarkus-Reseasy </artifactid>
</phụ thuộc>
<phụ thuộc>
<ProupId> IO.Quarkus </groupID>
<Partifactid> Quarkus-microprofile </artifactid>
</phụ thuộc>
`` `

Những phụ thuộc này sẽ cung cấp cho chúng tôi các API vi mô mà chúng tôi cần để xây dựng microservice của mình.

** Viết mã microservice **

Lớp `` GreetingResource` phơi bày một điểm cuối RESTful duy nhất cho phép chúng tôi nhận được một thông điệp chào hỏi.Mã sau đây cho thấy việc thực hiện lớp `` `heypingresource`:

`` `
gói org.example.quarkus.microprofile.kubernetes;

nhập javax.ws.rs.get;
nhập javax.ws.rs.path;

@Path ("/Chúc mừng")
Lớp học công khai Lời chào

@LẤY
chuỗi công khai getGreeting () {
Trở lại "Xin chào, Thế giới!";
}

}
`` `

** triển khai microservice cho kubernetes **

Để triển khai microservice của chúng tôi cho Kubernetes, chúng tôi có thể sử dụng lệnh sau:

`` `
Kubectl Áp dụng -F Kubernetes/Triển khai.YAML
`` `

Lệnh này sẽ tạo ra một triển khai Kubernetes mới cho microservice của chúng tôi.Sau đó, chúng ta có thể xác minh rằng việc triển khai đã được tạo thành công bằng cách chạy lệnh sau:

`` `
Kubectl được triển khai
`` `

Lệnh này sẽ liệt kê tất cả các triển khai trong cụm Kubernetes của chúng tôi.Đầu ra của lệnh nên bao gồm một triển khai có tên là `Quarkus-microprofile-kubernetes`.

Chúng tôi cũng có thể xác minh rằng microservice của chúng tôi đang chạy bằng cách chạy lệnh sau:

`` `
Kubectl nhận được pods
`` `

Lệnh này sẽ liệt kê tất cả các nhóm trong cụm Kubernetes của chúng tôi.Đầu ra của lệnh phải bao gồm một nhóm có tên là `Quarkus-microprofile-kubernetes- <pod-id>`.

** Kiểm tra microservice **

Chúng tôi có thể kiểm tra microservice của mình bằng lệnh sau:

`` `
Kubectl Exec -It Quarkus-Microprofile-Kubernetes- <Pod-id>-Curl Localhost: 8080/Lời chào
`` `

Lệnh này sẽ cuộn tròn điểm cuối `/chào của dịch vụ microservice của chúng tôi và in phản hồi cho bảng điều khiển.Đầu ra của lệnh phải như sau:

`` `
Chào thế giới!
`` `

**Phần kết luận**

Trong bài viết này, chúng tôi đã chỉ cho bạn cách xây dựng một microservice gốc Kubernetes với Quarkus và Microprofile.Chúng tôi bắt đầu bằng cách tạo một dự án Quarkus mới và sau đó thêm các phụ thuộc microprofile.Sau đó chúng tôi đã viết một dịch vụ microser đơn giản để lộ API RESTful.Sau đó, chúng tôi đã triển khai microservice của mình đến Kubernetes và kiểm tra nó bằng công cụ dòng lệnh `kubectl`.
=======================================
[Hạn Chế Số Lượng - Đặt Mua Ngay Để Không Bỏ Lỡ!]: (https://shorten.asia/RA4pjQD4)
=======================================
**Kubernetes Native Microservices with Quarkus and MicroProfile**

**Hashtags:** #Quarkus #Microprofile #Kubernetes

**Introduction**

Quarkus is a modern, lightweight, and Kubernetes-native Java framework that makes it easy to build microservices. MicroProfile is a set of specifications that define a consistent way to build microservices with Java. Together, Quarkus and MicroProfile make it possible to build fast, scalable, and portable microservices that can run on any Kubernetes-based platform.

In this article, we will show you how to build a Kubernetes-native microservice with Quarkus and MicroProfile. We will start by creating a new Quarkus project and then adding the MicroProfile dependencies. We will then write a simple microservice that exposes a RESTful API. We will then deploy our microservice to Kubernetes and test it using the `kubectl` command-line tool.

**Creating a Quarkus Project**

To create a new Quarkus project, we can use the following command:

```
mvn io.quarkus:quarkus-maven-plugin:1.13.1:create \
-DprojectGroupId=org.example \
-DprojectArtifactId=quarkus-microprofile-kubernetes \
-DclassName=org.example.quarkus.microprofile.kubernetes.GreetingResource
```

This command will create a new Quarkus project with a single Java class called `GreetingResource`. The `GreetingResource` class exposes a RESTful API that allows us to get a greeting message.

**Adding the MicroProfile Dependencies**

To add the MicroProfile dependencies to our project, we can add the following Maven dependencies to the `pom.xml` file:

```
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-resteasy</artifactId>
</dependency>
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-microprofile</artifactId>
</dependency>
```

These dependencies will provide us with the MicroProfile APIs that we need to build our microservice.

**Writing the Microservice Code**

The `GreetingResource` class exposes a single RESTful endpoint that allows us to get a greeting message. The following code shows the implementation of the `GreetingResource` class:

```
package org.example.quarkus.microprofile.kubernetes;

import javax.ws.rs.GET;
import javax.ws.rs.Path;

@Path("/greeting")
public class GreetingResource {

@GET
public String getGreeting() {
return "Hello, world!";
}

}
```

**Deploying the Microservice to Kubernetes**

To deploy our microservice to Kubernetes, we can use the following command:

```
kubectl apply -f kubernetes/deployment.yaml
```

This command will create a new Kubernetes deployment for our microservice. We can then verify that the deployment was created successfully by running the following command:

```
kubectl get deployments
```

This command will list all of the deployments in our Kubernetes cluster. The output of the command should include a deployment named `quarkus-microprofile-kubernetes`.

We can also verify that our microservice is running by running the following command:

```
kubectl get pods
```

This command will list all of the pods in our Kubernetes cluster. The output of the command should include a pod named `quarkus-microprofile-kubernetes-<pod-id>`.

**Testing the Microservice**

We can test our microservice using the following command:

```
kubectl exec -it quarkus-microprofile-kubernetes-<pod-id> -- curl localhost:8080/greeting
```

This command will curl the `/greeting` endpoint of our microservice and print the response to the console. The output of the command should be the following:

```
Hello, world!
```

**Conclusion**

In this article, we showed you how to build a Kubernetes-native microservice with Quarkus and MicroProfile. We started by creating a new Quarkus project and then adding the MicroProfile dependencies. We then wrote a simple microservice that exposes a RESTful API. We then deployed our microservice to Kubernetes and tested it using the `kubectl` command-line tool.
=======================================
[Nhận Mã Giảm Giá]: (https://shorten.asia/RA4pjQD4)
 
Join Telegram ToolsKiemTrieuDoGroup
Back
Top