Daniel Oh 发布的文章

在 Kubernetes 中运行无服务器函数时,实现更快的启动速度和更小的内存占用。

 title=

由于运行上千个应用程序 容器荚 Pod 所耗费的资源多,令它实现较少工作节点和资源占用所需成本也较高,所以在使用 Kubernetes 时,快速启动和较少的内存占用是至关重要的。在 Kubernetes 平台运行容器化微服务时,内存占用是比吞吐量更重要的考量因素,这是因为:

  • 由于需要持续运行,所以耗费资源更多(不同于 CPU 占用)
  • 微服务令开销成本成倍增加
  • 一个单体应用程序变为若干个微服务的情况(例如 20 个微服务占用的存储空间约有 20GB)

这些情况极大影响了无服务器函数的发展和 Java 部署模型。到目前为止,许多企业开发人员选择 Go、Python 或 Node.js 这些替代方案来解决性能瓶颈,直到出现了 Quarkus 这种基于 kubernetes 的原生 Java 堆栈,才有所改观。本文介绍如何在使用了 Quarkus 的 kubernetes 平台上进行性能优化,以便运行无服务器函数。

容器优先的设计理念

由于 Java 生态系统中传统的框架都要进行框架的初始化,包括配置文件的处理、classpath 的扫描、类加载、注解的处理以及构建元模型,这些过程都是必不可少的,所以它们都比较耗费资源。如果使用了几种不同的框架,所耗费的资源也是成倍增加。

Quarkus 通过“ 左移 shifting left ”,把所有的资源开销大的操作都转移到构建阶段,解决了这些 Java 性能问题。在构建阶段进行代码和框架分析、字节码转换和动态元模型生成,而且只有一次,结果是:运行时可执行文件经过高度优化,启动非常快,不需要经过那些传统的启动过程,全过程只在构建阶段执行一次。

 title=

更重要的是:Quarkus 支持构建原生可执行文件,它具有良好性能,包括快速启动和极小的 驻留集大小 resident set size (RSS)内存占用,跟传统的云原生 Java 栈相比,具备即时扩展的能力和高密度的内存利用。

 title=

这里有个例子,展示如何使用 Quarkus 将一个 Java 无服务器 项目构建为本地可执行文件。

1、使用 Quarkus 创建无服务器 Maven 项目

以下命令生成一个 Quarkus 项目,(例如 quarkus-serverless-native)以此创建一个简单的函数:

$ mvn io.quarkus:quarkus-maven-plugin:1.13.4.Final:create \
       -DprojectGroupId=org.acme \
       -DprojectArtifactId=quarkus-serverless-native \
       -DclassName="org.acme.getting.started.GreetingResource"

2、构建一个本地可执行文件

你需要使用 GraalVM 为 Java 程序构建一个本地可执行文件。你可以选择 GraalVM 的任何发行版,例如 Oracle GraalVM Community Edition (CE)Mandrel(Oracle GraalVM CE 的下游发行版)。Mandrel 是为支持 OpenJDK 11 上的 Quarkus-native 可执行文件的构建而设计的。

打开 pom.xml,你将发现其中的 native 设置。你将使用它来构建本地可执行文件。

<profiles>
    <profile>
        <id>native</id>
        <properties>
            <quarkus.package.type>native</quarkus.package.type>
        </properties>
    </profile>
</profiles>
注意: 你可以在本地安装 GraalVM 或 Mandrel 发行版。你也可以下载 Mandrel 容器映像来构建它(像我那样),因此你还需要在本地运行一个容器引擎(例如 Docker)。

假设你已经打开了容器运行时,此时需要运行一下 Maven 命令:

使用 Docker 作为容器引擎:

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

使用 Podman 作为容器引擎:

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

输出信息结尾应当是 BUILD SUCCESS

 title=

不借助 JVM 直接运行本地可执行文件:

$ target/quarkus-serverless-native-1.0.0-SNAPSHOT-runner

输出信息类似于:

__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \  
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/  
INFO  [io.quarkus] (main) quarkus-serverless-native 1.0.0-SNAPSHOT native
(powered by Quarkus xx.xx.xx.) Started in 0.019s. Listening on: http://0.0.0.0:8080
INFO [io.quarkus] (main) Profile prod activated.
INFO [io.quarkus] (main) Installed features: [cdi, kubernetes, resteasy]

简直是超音速!启动只花了 19 毫秒。你的运行时间可能稍有不同。

使用 Linux 的 ps 工具检测一下,结果内存占用还是很低。检测的方法是:在应用程序运行期间,另外打开一个终端,运行如下命令:

$ ps -o pid,rss,command -p $(pgrep -f runner)

输出结果类似于:

  PID    RSS COMMAND
10246  11360 target/quarkus-serverless-native-1.0.0-SNAPSHOT-runner

该进程只占 11MB 内存。非常小!

注意: 各种应用程序(包括 Quarkus)的驻留集大小和内存占用,都因运行环境而异,并随着应用程序载入而上升。

你也可以使用 REST API 访问这个函数。输出结果应该是 Hello RESTEasy:

$ curl localhost:8080/hello
Hello RESTEasy

3、把函数部署到 Knative 服务

如果你还没有创建命名空间,现在就在 OKD(OpenShift Kubernetes 发行版)创建一个命名空间(例如 quarkus-serverless-native),进而把这个本地可执行文件部署为无服务器函数。然后添加 quarkus-openshift 扩展:

$ ./mvnw -q quarkus:add-extension -Dextensions="openshift"

src/main/resources/application.properties 文件中添加以下内容,配置 Knative 和 Kubernetes 的相关资源:

quarkus.container-image.group=quarkus-serverless-native
quarkus.container-image.registry=image-registry.openshift-image-registry.svc:5000
quarkus.native.container-build=true
quarkus.kubernetes-client.trust-certs=true
quarkus.kubernetes.deployment-target=knative
quarkus.kubernetes.deploy=true
quarkus.openshift.build-strategy=docker

构建本地可执行文件,并把它直接部署到 OKD 集群:

$ ./mvnw clean package -Pnative
注意: 提前使用 oc login 命令,确保登录的是正确的项目(例如 quarkus-serverless-native)。

输出信息结尾应当是 BUILD SUCCESS。完成一个本地二进制文件的构建并部署为 Knative 服务需要花费几分钟。成功创建服务后,使用 kubectloc 命令工具,可以查看 Knative 服务和版本信息:

$ kubectl get ksvc
NAME                        URL   [...]
quarkus-serverless-native   http://quarkus-serverless-native-[...].SUBDOMAIN  True

$ kubectl get rev
NAME                              CONFIG NAME                 K8S SERVICE NAME                  GENERATION   READY   REASON
quarkus-serverless-native-00001   quarkus-serverless-native   quarkus-serverless-native-00001   1            True

4、访问本地可执行函数

运行 kubectl 命令,搜索无服务器函数的节点:

$ kubectl get rt/quarkus-serverless-native

输出信息类似于:

NAME                         URL                                                                                                          READY   REASON
quarkus-serverless-native   http://quarkus-serverless-restapi-quarkus-serverless-native.SUBDOMAIN   True

curl 命令访问上述信息中的 URL 字段:

$ curl http://quarkus-serverless-restapi-quarkus-serverless-native.SUBDOMAIN/hello

过了不超过一秒钟,你也会得到跟本地操作一样的结果:

Hello RESTEasy

当你在 OKD 群集中访问 Quarkus 运行中的节点的日志,你会发现本地可执行文件正在以 Knative 服务的形式运行。

 title=

下一步呢?

你可以借助 GraalVM 发行版优化 Java 无服务器函数,从而在 Knative 中使用 Kubernetes 将它们部署为无服务器函数。Quarkus 支持在普通的微服务中使用简易配置进行性能优化。

本系列的下一篇文章将指导你在不更改代码的情况下跨多个无服务器平台实现可移植函数。

(Daniel Oh, CC BY-SA 4.0)


via: https://opensource.com/article/21/6/java-serverless-functions-kubernetes

作者:Daniel Oh 选题:lujun9972 译者:cool-summer-021 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Quarkus 令你可以使用类似 Java 的技术开发无服务器的工作负载。

无服务器 Java 的研究始于函数 —— 就是按需求运行的一小段代码。这一阶段并没有持续很长时间。虽然在 1.0 阶段,基于虚拟机架构的函数使这种范式变得很流行,但它仍然有局限性,例如执行时间、协议和糟糕的本地开发体验,都不太理想,如下图所示。

开发者随后意识到,可以把同样的无服务器特性应用于微服务和 Linux 容器,带来的好处也是一样的。由此进入 1.5 阶段,在这个阶段,一些无服务器容器完全抽象化了 Kubernetes,通过 Knative 或其它位于它之上的抽象层来提供无服务器的体验。

在 2.0 阶段,无服务器开始处理更复杂的编排和集成模式,并结合某些层级的状态管理。更重要的是,开发者关注的是能否在旧的系统中使用熟悉的 Java 应用程序运行时来组合运行无服务器和非无服务器的工作负载。

The serverless Java journey

Java 开发者开始进行无服务器函数开发之前,第一步是要选择一种新的云原生 Java 框架,从而能够以快于传统单体应用程序的速度和较小的内存占用运行 Java 函数。这在各种基础设施环境中,包括物理服务器、虚拟机、多云或混合云环境中的容器,都是适用的。

开发者也有可能固执地选择 Spring 框架中的 Spring 云函数 来进行命令式和反应式函数的开发。Spring 也支持将 Java 函数部署到可安装的无服务器平台,比如 KubelessApache OpenWhiskFissionProject Riff。然而,人们担心 Spring 的启动慢、响应时间长以及内存占用大的问题。在诸如 Kubernetes 这种可扩展的容器环境中运行 Java 函数,这些问题可能会更严重。

Quarkus 是一个新推出的开源云原生 Java 框架,它有助于解决这些问题。它的作用是设计无服务器应用程序,以及编写运行于云基础设施(例如 Kubernetes)的云原生微服务。

Quarkus 重新审视了 Java,它使用了封闭的方法构建和运行 Java 程序。它把 Java 转变为一种可与 Go 相媲美的运行时。Quarkus 也包含 100 多种扩展功能,集成了企业级能力,例如数据库访问、无服务器集成、消息、安全、可观察性和业务自动化。

这里有一个简单例子,展现如何使用 Quarkus 创建一个 Java 无服务器项目的框架。

1、基于 Maven 创建一个 Quarkus 无服务器项目

安装一个本地 Kubernetes 集群,开发者有多种选择,包括 MinikubeOKD。因为使用 OKD 在 Knative 和 DevOps 工具上安装无服务器相关功能较方便,本文使用 OKD 安装集群。这些关于 OKD 安装Knative 操作员安装 的相关指南中提供了更多的设置资料。

下面的命令创建了一个 Quarkus 项目(例如 quarkus-serverless-restapi),对外暴露一个简单的 REST API,并下载 quarkus-openshift 扩展,用于 Knative 服务的部署:

$ mvn io.quarkus:quarkus-maven-plugin:1.13.4.Final:create \
       -DprojectGroupId=org.acme \
       -DprojectArtifactId=quarkus-serverless-restapi \
       -Dextensions="openshift" \
       -DclassName="org.acme.getting.started.GreetingResource"

2、在本地运行无服务器功能

使用 Quarkus 开发模式运行程序,检查 REST API 是否有效,稍稍调整一下代码:

$ ./mvnw quarkus:dev

输出如下内容:

__  ____  __  _____   ___  __ ____  ______ 
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
INFO  [io.quarkus] (Quarkus Main Thread) quarkus-serverless-restapi 1.0.0-SNAPSHOT on JVM (powered by Quarkus xx.xx.xx.) started in 2.386s. Listening on: http://localhost:8080
INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, kubernetes, resteasy]
注意: 保持 Quarkus 应用程序运行,需要使用 热部署 Live Coding 。这样,当代码修改后,你就不必重新构建、重新部署以及重启运行时。

现在,你可以使用一个 curl 命令快速访问 REST API。输出结果应当是 Hello RESTEasy:

$ curl localhost:8080/hello
Hello RESTEasy

GreetingResource.java 中修改返回值:

public String hello() {
        return "Quarkus Function on Kubernetes";
    }

再次访问 REST API,输出信息也会相应更新:

$ curl localhost:8080/hello
Quarkus Function on Kubernetes

普通的微服务跟无服务器函数之间的差别并不大。使用 Quarkus 的好处在于:开发者可以使用任何微服务,将 Kubernetes 部署为无服务器函数。

3、在 Knative 服务中部署相关的函数

如果你还没有创建命名空间,就在你的 OKD 集群上 创建命名空间(例如 quarkus-serverless-restapi),用来部署 Java 无服务器函数。

Quarkus 令开发者可以通过在 src/main/resources/application.properties 中添加以下变量,创建 Knative 和 Kubernetes 资源:

quarkus.container-image.group=quarkus-serverless-restapi <1>
quarkus.container-image.registry=image-registry.openshift-image-registry.svc:5000 <2>
quarkus.kubernetes-client.trust-certs=true <3>
quarkus.kubernetes.deployment-target=knative <4>
quarkus.kubernetes.deploy=true <5>
quarkus.openshift.build-strategy=docker <6>

说明:

  • <1> 在你部署无服务器应用程序的位置定义项目名
  • <2> 使用容器注册中心
  • <3> 在这个简单例子中,使用自签名证书,以便通过相关信任机制
  • <4> 允许创建 Knative 资源
  • <5> 指示在构建容器映像之后将扩展部署到 OpenShift
  • <6> 设置 Docker 构建策略

执行以下命令,构建应用程序,并直接部署到 OKD 集群:

$ ./mvnw clean package -DskipTests
注意: 应该提前使用 oc login 命令,确保登录到正确的项目(例如quarkus-serverless-restapi)。

输出结果应该以 BUILD SUCCESS 结束。

在对于 Knative 服务执行的 oc 命令中,加上标签:

$ oc label rev/quarkus-serverless-restapi-00001 
app.openshift.io/runtime=quarkus --overwrite

然后访问 OKD 网页控制台,就能进入 开发人员透视图中的拓扑视图。你可能会看到你的 容器荚 Pod (无服务器函数)已经缩小为零(白线圈)。

Topology view

4、在 Kubernetes 环境下测试函数

运行如下 oc 命令,搜索含有无服务器函数的路由:

$ oc get rt/quarkus-serverless-restapi
[...]
NAME                      URL                             READY   REASON
quarkus-serverless[...]   http://quarkus[...].SUBDOMAIN   True

使用 curl 命令访问搜索到的路由:

$ curl http://quarkus-serverless-restapi-quarkus-serverless-restapi.SUBDOMAIN/hello

过几秒钟,你可以得到跟在本地相同的结果:

Quarkus Function on Kubernetes

当你回到 OKD 集群内的拓扑图,Knative 服务会自动扩展。

Scaling the Knative Function

由于 Knative 服务的默认设置,其 pod 在 30 秒后会再次下降至零。

下一步呢?

无服务器不断地在演变,始于运行于虚拟机的函数,到后来的无服务器容器,并与企业原有系统集成。在此过程中,企业开发者借助 Quarkus,仍然可以使用自己熟悉的技术(比如 Java)创建一个项目,然后构建并部署到 Kubernetes。

本系列的下一篇文章将指导你优化 Kubernetes 中的 Java 无服务器函数,从而令程序启动更快,内存占用更小。

文内图像来自:Daniel Oh, CC BY-SA 4.0


via: https://opensource.com/article/21/6/java-serverless-functions

作者:Daniel Oh 选题:lkxed 译者:cool-summer-021 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

一本新的展示了开发者如何继续使用 Java 框架来构建新的无服务器功能的电子书。

 title=

无服务器 架构已经成为一种高效的解决方案,无论是物理服务器、虚拟机还是云环境,都可以根据实际工作负载调整超额配置和不足配置资源(如 CPU、内存、磁盘、网络)。然而,在选择新的编程语言来开发无服务器应用时,Java 开发者有一个担忧。对于云上的无服务器部署,尤其是 Kubernetes,Java 框架似乎过于沉重和缓慢。

作为 Java 开发者,如果可以继续使用 Java 框架来构建传统的云原生微服务以及同时构建新的无服务器功能呢?这种方法应该是令人兴奋的,因为你不必担心新的无服务器应用框架的学习曲线会很陡峭。

此外,如果 Java 框架不仅可以为开发者提供熟悉技术的乐趣,还可以在启动时以毫秒为单位优化 Kubernetes 中的 Java 无服务器功能,并提供微小的内存足迹,又会怎样?

什么是 Quarkus?

Quarkus 是一个新的 Java 框架,可以为 Java 开发者、企业架构师和 DevOps 工程师提供这些功能和好处。它旨在设计无服务器应用,并编写云原生微服务,以便在云基础设施(例如 Kubernetes)上运行。

Quarkus 还支持一个名为 Funqy 的可移植 Java API 扩展,供开发者编写和部署无服务器功能到异构无服务器运行时。

Quarkus Funqy 使开发者能够将 CloudEvents 与 Knative 环境中的无服务器函数绑定,以处理反应式流。这有利于开发者建立一个通用的消息传递格式来描述事件,提高多云和混合云平台之间的互操作性。

在我的新电子书 《Java 无服务器功能指南》的帮助下,开始你的 Quarkus 之旅。与他人分享你的 Quarkus 经验,让大家都能享受到用 Java 和 Quarkus 进行的无服务器开发。


via: https://opensource.com/article/21/8/java-quarkus-ebook

作者:Daniel Oh 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

开发和实施云原生(容器优先)软件的检查清单。

 title=

许多年来,单体应用是实现业务需求的标准企业架构。但是,当云基础设施开始以规模和速度为业务加速,这种情况就发生了重大变化。应用架构也发生了转变,以适应云原生应用和 微服务无服务器 以及事件驱动的服务,这些服务运行在跨混合云和多云平台的不可变的基础设施上。

云原生与 Kubernetes 的联系

根据 云原生计算基金会 (CNCF) 的说法:

“云原生技术使企业能够在现代动态环境中建立和运行可扩展的应用,如公共云、私有云和混合云。容器、服务网格、微服务、不可变的基础设施和声明式 API 就是这种方法的典范。”

“这些技术使松散耦合的系统具有弹性、可管理和可观察性。与强大的自动化相结合,它们使工程师能够以最小的工作量频繁地、可预测地进行重要的改变。”

Kubernetes 这样的容器编排平台允许 DevOps 团队建立不可变的基础设施,以开发、部署和管理应用服务。现在,快速迭代的速度与业务需求相一致。构建容器以在 Kubernetes 中运行的开发人员需要一个有效的地方来完成。

云原生软件的要求

创建云原生应用架构需要哪些能力,开发人员将从中获得哪些好处?

虽然构建和架构云原生应用的方法有很多,但以下是一些需要考虑的部分:

  • 运行时: 它们更多是以容器优先或/和 Kubernetes 原生语言编写的,这意味着运行时会如 Java、Node.js、Go、Python 和 Ruby。
  • 安全: 在多云或混合云应用环境中部署和维护应用时,安全是最重要的,应该是环境的一部分。
  • 可观察性: 使用 Prometheus、Grafana 和 Kiali 等工具,这些工具可以通过提供实时指标和有关应用在云中的使用和行为的更多信息来增强可观察性。
  • 效率: 专注于极小的内存占用、更小的构件大小和快速启动时间,使应用可跨混合/多云平台移植。
  • 互操作性: 将云原生应用与能够满足上述要求的开源技术相结合,包括 Infinispan、MicroProfile、Hibernate、Kafka、Jaeger、Prometheus 等,以构建标准运行时架构。
  • DevOps/DevSecOps: 这些方法论是为持续部署到生产而设计的,与最小可行产品 (MVP) 一致,并将安全作为工具的一部分。

让云原生具体化

云原生似乎是一个抽象的术语,但回顾一下定义并像开发人员一样思考可以使其更加具体。为了使云原生应用获得成功,它们需要包括一长串定义明确的组成清单。

你是如何规划云原生应用的设计的?在评论中分享你的想法。


via: https://opensource.com/article/20/1/cloud-native-software

作者:Daniel Oh 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Java 仍是开发企业应用程序最流行的语言之一。那么,为什么 无服务器 serverless 开发人员对它望而却步?

 title=

几十年来,企业已经在各类平台上开发了关键业务应用程序,包括物理服务器、虚拟机和云环境。这些应用程序在各行各业都有一个共同点,那就是无论需求如何,它们都需要持续可用(24x7x365),保证稳定性、可靠性和性能。因此,即使实际资源利用率低于 50%,每个企业都必须付出高额成本维护基础架构(如 CPU、内存、磁盘、网络等)。

无服务器架构是为了帮助解决这些问题而产生的。无服务器允许开发人员按需构建和运行应用程序,保证高可用性,不必在多云和混合云环境中管理服务器。在幕后,无服务器拓扑中仍有很多服务器,但它们是从应用程序开发中抽象出来的。相反,云提供商使用无服务器进行资源管理,例如配置、维护、联网和扩展服务器实例。

由于其高效性,无服务器开发模式现在是一些企业的需求,这些企业希望按需启动服务,而不是一直运行服务。

许多新建的开源项目用来在 Kubernetes 集群上通过 Linux 容器包来管理无服务器应用程序。CNCF 的《交互式无服务器全景》 是一份关于开源项目、工具、框架和公共云平台的指南,帮助 DevOps 团队处理无服务器应用程序。

 title=

开发人员可以编写代码,然后将其快速部署到各种无服务器环境中。然后,无服务器应用程序响应需求,并根据需要自动伸缩扩展。

你可能想知道什么编程语言和运行环境最适合无服务器应用程序开发,以便与上图中的技术集成。这个问题不只一个答案,但是让我们退一步来讨论在企业生产环境中开发业务应用程序最流行的应用程序运行环境:Java。

Developer Economics 称,截至 2020 年第三季度,仍有 800 多万家企业开发人员在使用 Java 来实现其业务需求。然而,根据 2020 年的一项调查,Java(占比 6%)显然不是有前瞻意识的开发人员的首选,他们使用当前云服务做开发。

 title=

来自 NewRelic 无服务器基准报告的数据(Daniel Oh, CC BY-SA 4.0

资源使用、响应时间和延迟在无服务器开发中至关重要。公有云提供商提供的无服务器产品通常是按需计量的,只有在无服务器应用程序启动时,才会通过事件驱动的执行模式收费。因此,当无服务器应用程序闲置或缩减为零时,企业无需支付任何费用。

带有容器的 Java 状态

在这种背景下,你可能会问:“既然现有业务应用程序很可能是在 Java 技术上开发的,那么开发人员为什么不尝试使用 Java 栈进行无服务器应用程序开发呢?

隐藏的真相是:很难在新的不可变更的基础设施(例如 Kubernetes 这样的容器平台)中优化 Java 应用程序。

 title=

该图描述了 Java 进程与竞争的语言、框架(如 Node.jsGo)之间内存资源使用的差异。Java HotSpot 占用资源最大,其中包括每个 Java 虚拟机 Java Virtual Machine (JVM)实例分配的堆内存。中间显示了 Node.js 每个进程要比 Java 小得多。最后,Go 是一种流行的云服务编程语言,因为它的内存消耗最低。

如你所见,当你在这张图从左到右走,你会看到更密的节点。这就是开发人员在云、容器和 Kubernetes 上编写无服务器应用程序时回避 Java(包括 Spring Boot,一种顽固的微服务 Java 框架)的原因。

下一步是什么?

企业可以通过实现无服务器应用程序获得明显的好处,但是资源密度问题导致他们避免使用 Java 堆栈在 Kubernetes 上开发无服务器应用程序开发。但是选择其他语言会给全球数百万 Java 开发人员带来学习负担。因此,在本系列的下一篇文章中,我将指导你如何开始使用 Java 无服务器函数,而不是使用其他语言。


via: https://opensource.com/article/21/5/what-serverless-java

作者:Daniel Oh 选题:lujun9972 译者:DCOLIVERSUN 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在微服务环境中,服务网格为开发和运营提供了好处。

 title=

很多开发者不知道为什么要关心 服务网格 Service Mesh 。这是我在开发者见面会、会议和实践研讨会上关于云原生架构的微服务开发的演讲中经常被问到的问题。我的回答总是一样的:“只要你想简化你的微服务架构,它就应该运行在 Kubernetes 上。”

关于简化,你可能也想知道,为什么分布式微服务必须设计得如此复杂才能在 Kubernetes 集群上运行。正如本文所解释的那样,许多开发人员通过服务网格解决了微服务架构的复杂性,并通过在生产中采用服务网格获得了额外的好处。

什么是服务网格?

服务网格是一个专门的基础设施层,用于提供一个透明的、独立于代码的 (polyglot) 方式,以消除应用代码中的非功能性微服务能力。

 title=

为什么服务网格对开发者很重要

当开发人员将微服务部署到云时,无论业务功能如何,他们都必须解决非功能性微服务功能,以避免级联故障。这些功能通常可以体现在服务发现、日志、监控、 韧性 resiliency 、认证、 弹性 elasticity 和跟踪等方面。开发人员必须花费更多的时间将它们添加到每个微服务中,而不是开发实际的业务逻辑,这使得微服务变得沉重而复杂。

随着企业加速向云计算转移,服务网格 可以提高开发人员的生产力。Kubernetes 加服务网格平台不需要让服务负责处理这些复杂的问题,也不需要在每个服务中添加更多的代码来处理云原生的问题,而是负责向运行在该平台上的任何应用(现有的或新的,用任何编程语言或框架)提供这些服务。那么微服务就可以轻量级,专注于其业务逻辑,而不是云原生的复杂性。

为什么服务网格对运维很重要

这并没有回答为什么运维团队需要关心在 Kubernetes 上运行云原生微服务的服务网格。因为运维团队必须确保在 Kubernetes 环境上的大型混合云和多云上部署新的云原生应用的强大安全性、合规性和可观察性。

服务网格由一个用于管理代理路由流量的控制平面和一个用于注入 边车 Sidecar 的数据平面组成。边车允许运维团队做一些比如添加第三方安全工具和追踪所有服务通信中的流量,以避免安全漏洞或合规问题。服务网格还可以通过在图形面板上可视化地跟踪指标来提高观察能力。

如何开始使用服务网格

对于开发者和运维人员,以及从应用开发到平台运维来说,服务网格可以更有效地管理云原生功能。

你可能想知道从哪里开始采用服务网格来配合你的微服务应用和架构。幸运的是,有许多开源的服务网格项目。许多云服务提供商也在他们的 Kubernetes 平台中提供 服务网格。

 title=

你可以在 CNCF Service Mesh Landscape 页面中找到最受欢迎的服务网格项目和服务的链接。


via: https://opensource.com/article/21/3/service-mesh

作者:Daniel Oh 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出