作者选择了 COVID-19 救援基金作为 Write for Donations计划的一部分接受捐款。
介绍
Kubernetes和它所允许的微服务架构可以创建非常高效和可扩展的系统,但是当这些微服务之一出现性能问题时会出现问题。通常,我们首先注意到我们面向客户的服务的响应时间越来越长。问题可能是背后服务之一,或者可能是超出其最佳容量的数据库。
[Jaeger 是分布式跟踪解决方案,也是 Cloud Native Computing Foundation 的孵化项目(https://www.cncf.io/announcements/2019/10/31/cloud-native-computing-foundation-announces-jaeger-graduation/)的毕业生)。它提供了可视化跟踪的愉快的用户界面,以及收集跟踪的 Jaeger sidecars以及其他几个组件。
在本教程中,我们将部署一个非常小的分布式应用程序到 Kubernetes 集群中,并使用我们的代码中的睡眠函数模拟性能延迟。
如果您正在寻找一个管理的Kubernetes托管服务,请查看我们的简单的,用于增长的管理的Kubernetes服务(https://www.digitalocean.com/products/kubernetes)。
前提条件
在您开始之前,您将需要以下工具和帐户:
要在 DigitalOcean 上创建一个 Kubernetes 集群,请阅读我们的 Kubernetes Quickstart。 要连接到集群,请阅读 [How to Connect to a DigitalOcean Kubernetes Cluster]([ ])]。
- Docker 已安装。 请遵循我们在 How To Install and Use Docker上的教程以获取说明。 Docker 的网站为 macOS 和 Windows 等其他操作系统提供安装说明([ ])。
步骤 1 — 构建样本应用程序
为了测试Jaeger的追踪能力,我们将构建并部署一个样本应用程序,‘sammy-jaeger’,该应用程序使用两个服务:一个用于前端和一个用于后端。
为了模拟性能问题,我们将编码一个随机睡眠函数,每次前端向后端发送一个GET请求时,它就会执行。
首先,让我们创建一个项目目录结构,并导航内部:
1mkdir -p ./sammy-jaeger/frontend ./sammy-jaeger/backend && cd ./sammy-jaeger
我们现在有一个根目录,‘sammy-jaeger’,和两个子目录:
1[secondary_label output]
2.
3├── backend
4└── frontend
我们还将更改为 root 目录, /sammy-jaeger. 我们将从这里运行所有剩余的命令。
让我们开始构建前端应用程序。
构建前端应用程序
使用您喜爱的文本编辑器,创建并打开一个名为 frontend.py 的新文件在 ./frontend:
1nano ./frontend/frontend.py
这将导入Flask,构建我们的计数函数,并为HTTP请求定义一条路线:
1[label ./frontend/frontend.py]
2import os
3import requests
4from flask import Flask
5app = Flask(__name__)
6
7def get_counter(counter_endpoint):
8 counter_response = requests.get(counter_endpoint)
9 return counter_response.text
10
11def increase_counter(counter_endpoint):
12 counter_response = requests.post(counter_endpoint)
13 return counter_response.text
14
15@app.route('/')
16def hello_world():
17 counter_service = os.environ.get('COUNTER_ENDPOINT', default="https://localhost:5000")
18 counter_endpoint = f'{counter_service}/api/counter'
19 counter = get_counter(counter_endpoint)
20
21 increase_counter(counter_endpoint)
22
23 return f"""Hello, World!
24
25You're visitor number {counter} in here!\n\n"""
我们正在导入三种模块. os模块将与我们的操作系统进行通信. requests模块是发送HTTP请求的库。
然后我们定义了我们的get_counter()和increase_counter()函数,这两个函数都接受了counter_endpoint参数。
然后我们定义我们的路线 /,这将叫另一个函数名为 hello_world(). 这个函数将检索我们的后端pod 的 URL 和端口,分配给一个变量,然后将该变量传递给我们的前两个函数, get_counter() 和 increase_counter(),这将发送到后端的 GET和 POST 请求。
您可能已经注意到我们没有创建Python环境,也没有在本地机器上安装pip。
保存并关闭frontend.py。
现在我们将为前端应用程序构建一个 Dockerfile。
在./frontend中创建并打开新的Dockerfile:
1nano ./frontend/Dockerfile
添加以下内容:
1[label ./frontend/Dockerfile]
2FROM alpine:3.8
3
4RUN apk add --no-cache py3-pip python3 && \
5 pip3 install flask requests
6
7COPY . /usr/src/frontend
8
9ENV FLASK_APP frontend.py
10
11WORKDIR /usr/src/frontend
12
13CMD flask run --host=0.0.0.0 --port=8000
在这个Dockerfile中,我们指示我们的图像从基础上构建 Alpine Linux图像,然后我们安装Python3,pip和几个额外的依赖。
保存并关闭文件。
现在,让我们为我们的前端应用程序构建Docker图像,并将其推到Docker Hub中的存储库。
首先,请检查您是否已登录到 Docker Hub:
1docker login --username=your_username --password=your_password
构建图像:
1docker build -t your_username/do-visit-counter-frontend:v1 ./frontend
现在将图像推到Docker Hub:
1docker push your_username/do-visit-counter-frontend:v1
我们的前端应用程序现在是在Docker Hub中构建并可用,但是在我们部署到Kubernetes之前,让我们编码并构建我们的后端应用程序。
构建后台应用程序
后端应用程序需要与前端所需的相同步骤。
首先,创建并打开名为 backend.py 的文件在 ./backend 中:
1nano ./backend/backend.py
添加以下内容,将定义两个函数和另一个路径:
1[label ./backend/backend.py]
2from random import randint
3from time import sleep
4
5from flask import request
6from flask import Flask
7app = Flask(__name__)
8
9counter_value = 1
10
11def get_counter():
12 return str(counter_value)
13
14def increase_counter():
15 global counter_value
16 int(counter_value)
17 sleep(randint(1,10))
18 counter_value += 1
19 return str(counter_value)
20
21@app.route('/api/counter', methods=['GET', 'POST'])
22def counter():
23 if request.method == 'GET':
24 return get_counter()
25 elif request.method == 'POST':
26 return increase_counter()
我们正在导入几个模块,包括随机和睡眠。然后我们将我们的计数值设置为1并定义两个函数。第一个,get_counter,返回当前计数值,该值被存储为counter_value。第二个函数,increase_counter,执行两个操作。
后端还有一条路线(/api/counter),它接受两种方法: POST和 GET.
当我们使用 GET 方法调用此路线时,它调用 get_counter() 并返回我们的计数值.当我们使用 POST 方法调用此路线时,它调用 increase_counter() 并在等待随机时间时增加计数的值。
保存并关闭文件。
我们的后端应用程序还需要自己的Dockerfile,几乎与前端版本相同。
在./backend中创建并打开第二个Dockerfile:
1nano ./backend/Dockerfile
添加以下内容. 这里的一个主要差异,除了filepaths之外,将是端口:
1[label ./backend/Dockerfile]
2FROM alpine:3.8
3
4RUN apk add --no-cache py3-pip python3 && \
5 pip3 install flask
6
7COPY . /usr/src/backend
8
9ENV FLASK_APP backend.py
10
11WORKDIR /usr/src/backend
12
13CMD flask run --host=0.0.0.0 --port=5000
保存并关闭文件。
现在构建图像:
1docker build -t your_username/do-visit-counter-backend:v1 ./backend
将其推到 Docker Hub:
1docker push your_username/do-visit-counter-backend:v1
随着我们的应用程序在Docker Hub上可用,我们现在已经准备好将其部署到我们的集群中,并在下一步测试它。
步骤 2 — 部署和测试应用程序
编写我们的代码和发布我们的容器是我们的第一个重大步骤,现在我们需要部署到Kubernetes并测试基本应用程序,然后我们可以添加Jaeger并探索分布式跟踪的潜力。
让我们从部署和测试开始。
此时此刻,我们的目录树看起来像这样:
1.
2├── backend
3│ ├── Dockerfile
4│ └── backend.py
5└── frontend
6 ├── Dockerfile
7 └── frontend.py
要将此应用程序部署到我们的集群中,我们还需要两个 Kubernetes manifests;一个用于每个应用程序的一半。
在 `./frontend 中创建并打开新的 manifest 文件:
1nano ./frontend/deploy_frontend.yaml
此宣言将指定Kubernetes如何构建我们的 部署(请记住用您的Docker Hub用户名更换突出的部分):
1[label ./frontend/deploy_frontend.yaml]
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: do-visit-counter-frontend
6 labels:
7 name: do-visit-counter-frontend
8spec:
9 replicas: 1
10 selector:
11 matchLabels:
12 app: do-visit-counter-frontend
13 template:
14 metadata:
15 labels:
16 app: do-visit-counter-frontend
17 spec:
18 containers:
19 - name: do-visit-counter-frontend
20 image: your_dockerhub_username/do-visit-counter-frontend:v1
21 imagePullPolicy: Always
22 env:
23 - name: COUNTER_ENDPOINT
24 value: "http://do-visit-counter-backend.default.svc.cluster.local:5000"
25 ports:
26 - name: frontend-port
27 containerPort: 8000
28 protocol: TCP
我们已经指定了Kubernetes来构建一个部署,将其命名为Do-visit-counter-frontend,并使用我们的前端图像在Docker Hub上部署一个副本,我们还配置了一个名为COUNTER_ENDPOINT的环境变量来链接我们的应用程序的两半。
保存并关闭文件。
现在,为我们的后端应用程序在 ./backend 中创建宣言:
1nano ./backend/deploy_backend.yaml
添加以下内容,再次用您的 Docker Hub 用户名取代突出的部分:
1[label ./backend/deploy_backend.yaml]
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: do-visit-counter-backend
6 labels:
7 name: do-visit-counter-backend
8spec:
9 replicas: 1
10 selector:
11 matchLabels:
12 app: do-visit-counter-backend
13 template:
14 metadata:
15 labels:
16 app: do-visit-counter-backend
17 spec:
18 containers:
19 - name: do-visit-counter-backend
20 image: your_dockerhub_username/do-visit-counter-backend:v1
21 imagePullPolicy: Always
22 ports:
23 - name: backend-port
24 containerPort: 5000
25 protocol: TCP
26---
27apiVersion: v1
28kind: Service
29metadata:
30 name: do-visit-counter-backend
31spec:
32 selector:
33 app: do-visit-counter-backend
34 ports:
35 - protocol: TCP
36 port: 5000
37 targetPort: 5000
在本宣言中,您正在为我们的后端定义一个部署和一个 服务。 该部署描述了如何和容器将运行什么。 请注意,我们的端口已从前端的8000改为后端的5000。
保存并关闭文件。
现在让我们使用kubectl部署我们的计数器到集群中,从前端开始:
1kubectl apply -f ./frontend/deploy_frontend.yaml
然后,将后台部署到:
1kubectl apply -f ./backend/deploy_backend.yaml
要验证一切正常运行,请拨打kubectl get pods:
1kubectl get pods
你会看到这样的输出:
1[secondary_label Output]
2NAME READY STATUS RESTARTS AGE
3do-visit-counter-backend-79f6964-prqpb 1/1 Running 0 3m
4do-visit-counter-frontend-6985bdc8fd-92clz 1/1 Running 0 3m
我们希望所有 pods 都处于准备状态.如果它们尚未准备好,请等待几分钟,然后重新启动以前的命令。
最后,我们想使用我们的应用程序。为了做到这一点,我们将从集群中转发端口,然后使用弯曲命令与前端进行通信。
使用kubectl来转发端口:
1kubectl port-forward $(kubectl get pods -l=app="do-visit-counter-frontend" -o name) 8000:8000
现在,在第二个终端窗口中,向前端应用程序发送三个请求:
1[environment second]
2for i in 1 2 3; do curl localhost:8000; done
每个弯曲的呼叫都会增加访问号码,你会看到这样的输出:
1[secondary_label Output]
2[environment second]
3Hello, World!
4
5You're visitor number 1 in here!
6
7Hello, World!
8
9You're visitor number 2 in here!
10
11Hello, World!
12
13You're visitor number 3 in here!
我们的访客计数器正在正常工作,但您可能注意到每个响应之间存在延迟,这是我们睡眠功能的结果,该功能模拟了性能延迟。
随着我们的分布式应用程序的准备,是时候安装Jaeger并跟踪这些事件了。
步骤 3 — 部署 Jaeger
收集痕迹并可视化它们是Jaeger的专长,在这个步骤中,我们将部署Jaeger到我们的集群中,以便它可以找到我们的性能延迟。
Jaeger的官方文档包括安装Jaeger操作员的命令。它还包括四个额外的宣言,您必须部署才能使该工具工作。
首先,创建由Jaeger操作员要求的自定义资源定义(https://kubernetes.io/docs/concepts/services-networking/)。
1kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing.io_jaegers_crd.yaml
然后,创建一个(LINK0)、一个(LINK1)、一个(LINK2)的(Role Binding)和一个(LINK2)的(Role-Based Access Control):
1kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml
2kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml
3kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml
最后,部署Jaeger操作员:
1kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/operator.yaml
操作员本身并不意味着我们有Jaeger工作,这就是定义自定义资源的作用。我们需要创建一个描述我们希望操作员管理的Jaeger实例的资源。
使用 heredoc从命令行创建此资源:
1kubectl apply -f - <<EOF
2apiVersion: jaegertracing.io/v1
3kind: Jaeger
4metadata:
5 name: simplest
6EOF
点击进入来创建资源。
现在再检查你的部署:
1kubectl get pods
您将看到您的Jaeger操作员的输出和最简单的部署:
1[secondary_label Output]
2NAME READY STATUS RESTARTS AGE
3do-visit-counter-backend-79f6964-prqpb 1/1 Running 0 3m
4do-visit-counter-frontend-6985bdc8fd-92clz 1/1 Running 0 3m
5jaeger-operator-547567dddb-rxsd2 1/1 Running 0 73s
6simplest-759cb7d586-q6x28 1/1 Running 0 42s
为了验证Jaeger是否正常工作,让我们转发其端口,看看我们是否可以访问用户界面:
1kubectl port-forward $(kubectl get pods -l=app="jaeger" -o name) 16686:16686
打开浏览器并导航到`http://localhost:16686′′。 Jaeger UI 将加载。
我们的应用程序和Jaeger都在工作,在下一步,我们将添加仪器来让Jaeger收集数据并找到我们的性能延迟。
步骤 4 — 添加工具
虽然Jaeger在使用Kubernetes时会自动化许多任务,但我们仍然需要将仪器手动添加到我们的应用程序中,幸运的是,我们有Flask-OpenTracing模块(https://github.com/opentracing-contrib/python-flask)来处理这个任务。
OpenTracing是分布式跟踪的标准之一。它由Jaeger的作者提出,目的是支持其他跟踪工具,它是供应商中性的,支持许多不同的编程语言和流行的框架。
与所有OpenTracing实现一样,我们需要通过添加Jaeger配置并将跟踪装饰器附加到我们想要跟踪的端点来修改我们的原始应用程序。
让我们将Flask-OpenTracing添加到我们的前端代码中。
重新打开.frontend.py:
1nano ./frontend/frontend.py
现在添加以下突出的代码,将嵌入 OpenTracing:
1[label ./frontend/frontend.py]
2import os
3import requests
4from flask import Flask
5from jaeger_client import Config
6from flask_opentracing import FlaskTracing
7
8app = Flask(__name__)
9config = Config(
10 config={
11 'sampler':
12 {'type': 'const',
13 'param': 1},
14 'logging': True,
15 'reporter_batch_size': 1,},
16 service_name="service")
17jaeger_tracer = config.initialize_tracer()
18tracing = FlaskTracing(jaeger_tracer, True, app)
19
20def get_counter(counter_endpoint):
21 counter_response = requests.get(counter_endpoint)
22 return counter_response.text
23
24def increase_counter(counter_endpoint):
25 counter_response = requests.post(counter_endpoint)
26 return counter_response.text
27
28@app.route('/')
29def hello_world():
30 counter_service = os.environ.get('COUNTER_ENDPOINT', default="https://localhost:5000")
31 counter_endpoint = f'{counter_service}/api/counter'
32 counter = get_counter(counter_endpoint)
33
34 increase_counter(counter_endpoint)
35
36 return f"""Hello, World!
37
38You're visitor number {counter} in here!\n\n"""
您可以了解有关 Flask OpenTracing 配置在他们的 GitHub 页面上的更多信息。
现在打开您的后端应用程序代码:
1nano ./backend/backend.py
添加突出的代码. 这是我们在frontend.py中放置的相同代码:
1[label ./backend/backend.py]
2from random import randint
3from time import sleep
4
5from flask import Flask
6from flask import request
7from jaeger_client import Config
8from flask_opentracing import FlaskTracing
9
10app = Flask(__name__)
11config = Config(
12 config={
13 'sampler':
14 {'type': 'const',
15 'param': 1},
16 'logging': True,
17 'reporter_batch_size': 1,},
18 service_name="service")
19jaeger_tracer = config.initialize_tracer()
20tracing = FlaskTracing(jaeger_tracer, True, app)
21
22counter_value = 1
23
24def get_counter():
25 return str(counter_value)
26
27def increase_counter():
28 global counter_value
29 int(counter_value)
30 sleep(randint(1,10))
31 counter_value += 1
32 return str(counter_value)
33
34@app.route('/api/counter', methods=['GET', 'POST'])
35def counter():
36 if request.method == 'GET':
37 return get_counter()
38 elif request.method == 'POST':
39 return increase_counter()
保存并关闭文件。
由于我们正在添加额外的库,我们也必须对这两个服务进行修改。
打开对前端的Dockerfile:
1nano ./frontend/Dockerfile
添加突出的代码:
1[label ./frontend/Dockerfile]
2FROM alpine:3.8
3
4RUN apk add --no-cache py3-pip python3 && \
5 pip3 install flask requests Flask-Opentracing jaeger-client
6
7COPY . /usr/src/frontend
8
9ENV FLASK_APP frontend.py
10
11WORKDIR /usr/src/frontend
12
13CMD flask run --host=0.0.0.0 --port=8000
保存并关闭文件。
现在打开后端的Dockerfile:
1nano ./backend/Dockerfile
添加突出的代码:
1[label ./backend/Dockerfile]
2FROM alpine:3.8
3
4RUN apk add --no-cache py3-pip python3 && \
5 pip3 install flask Flask-Opentracing jaeger-client
6
7COPY . /usr/src/backend
8
9ENV FLASK_APP backend.py
10
11WORKDIR /usr/src/backend
12
13CMD flask run --host=0.0.0.0 --port=5000
随着这些变化,我们希望重建和推动我们容器的新版本。
构建并推动前端应用程序. 请记住末尾的v2标签:
1docker build -t your_username/do-visit-counter-frontend:v2 ./frontend
2docker push your_username/do-visit-counter-frontend:v2
现在构建并推动后端应用程序:
1docker build -t your_username/do-visit-counter-backend:v2 ./backend
2docker push your_username/do-visit-counter-backend:v2
我们的分布式跟踪系统需要一个最后的部分:我们希望将Jaeger侧车注入我们的应用程序插槽,以便听取从pod的痕迹,并将其传送到Jaeger服务器。
打开前端的宣言:
1nano ./frontend/deploy_frontend.yaml
添加突出的代码. 请注意,我们也将我们的图像替换为v2版本. 请确保修改该行并添加您的 Docker Hub 用户名:
1[label ./frontend/deploy_frontend.yaml]
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: do-visit-counter-frontend
6 labels:
7 name: do-visit-counter-frontend
8 annotations:
9 "sidecar.jaegertracing.io/inject": "true"
10spec:
11 replicas: 1
12 selector:
13 matchLabels:
14 app: do-visit-counter-frontend
15 template:
16 metadata:
17 labels:
18 app: do-visit-counter-frontend
19 spec:
20 containers:
21 - name: do-visit-counter-frontend
22 image: your_dockerhub_username/do-visit-counter-frontend:v2
23 imagePullPolicy: Always
24 env:
25 - name: COUNTER_ENDPOINT
26 value: "http://do-visit-counter-backend.default.svc.cluster.local:5000"
27 ports:
28 - name: frontend-port
29 containerPort: 8000
30 protocol: TCP
(此注释将注射一个Jaeger sidecar到我们的pod)(https://www.jaegertracing.io/docs/1.19/operator/#production-strategy)
保存并关闭文件。
现在打开后端的宣言:
1nano ./backend/deploy_backend.yaml
重复过程,添加突出线来注入Jaeger侧面车,并更新您的图像标签:
1[label ./backend/deploy_backend.yaml]
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: do-visit-counter-backend
6 labels:
7 name: do-visit-counter-backend
8 annotations:
9 "sidecar.jaegertracing.io/inject": "true"
10spec:
11 replicas: 1
12 selector:
13 matchLabels:
14 app: do-visit-counter-backend
15 template:
16 metadata:
17 labels:
18 app: do-visit-counter-backend
19 spec:
20 containers:
21 - name: do-visit-counter-backend
22 image: your_dockerhub_username/do-visit-counter-backend:v2
23 imagePullPolicy: Always
24 ports:
25 - name: backend-port
26 containerPort: 5000
27 protocol: TCP
28---
29apiVersion: v1
30kind: Service
31metadata:
32 name: do-visit-counter-backend
33spec:
34 selector:
35 app: do-visit-counter-backend
36 ports:
37 - protocol: TCP
38 port: 5000
39 targetPort: 5000
有了新的宣言,我们需要将它们应用到群集中,然后等待 pods 创建。
让我们删除我们的旧资源:
1kubectl delete -f ./frontend/deploy_frontend.yaml
2kubectl delete -f ./backend/deploy_backend.yaml
然后替换它们:
1kubectl apply -f ./frontend/deploy_frontend.yaml
2kubectl apply -f ./backend/deploy_backend.yaml
这一次,我们的应用程序的潜将由两个容器组成:一个用于应用程序,另一个用于Jaeger侧面车。
使用kubectl来检查:
1kubectl get pods
我们的应用 pods 现在在准备列中出现2/2:
1[secondary_label Output]
2NAME READY STATUS RESTARTS AGE
3jaeger-operator-547567dddb-rxsd2 1/1 Running 0 23m
4simplest-759cb7d586-q6x28 1/1 Running 0 22m
5do-visit-counter-backend-694c7db576-jcsmv 2/2 Running 0 73s
6do-visit-counter-frontend-6d7d47f955-lwdnf 2/2 Running 0 42s
有了我们的侧面车和仪器,我们现在可以重新启动我们的程序,并调查Jaeger UI中的痕迹。
步骤5 —在Jaeger中调查痕迹
现在我们可以收获跟踪的好处. 这里的目标是通过查看Jaeger UI来看看哪些调用可能是一个性能问题. 当然,如果我们想在UI中看到一些痕迹,我们首先必须使用我们的应用程序生成一些数据。
让我们通过打开第二和第三个终端窗口来设置这一点,我们将使用两个窗口将Jaeger和我们的应用程序发送前进,第三个窗口将通过弯曲发送HTTP请求到我们的机器的前端。
在第一个窗口中,向前端服务的端口转发:
1kubectl port-forward $(kubectl get pods -l=app="do-visit-counter-frontend" -o name) 8000:8000
在第二个窗口中,转向Jaeger的端口:
1[environment second]
2kubectl port-forward $(kubectl get pods -l=app="jaeger" -o name) 16686:16686
在第三个窗口中,使用弯曲在循环中生成10个HTTP请求:
1[environment third]
2for i in 0 1 2 3 4 5 6 7 8 9; do curl localhost:8000; done
你会像以前一样得到一个输出:
1[secondary_label Output]
2[environment third]
3Hello, World!
4
5You're visitor number 1 in here!
6
7Hello, World!
8
9You're visitor number 2 in here!
10
11. . .
12
13Hello, World!
14
15You're visitor number 10 in here!
这将为我们提供足够不同的数据点,以便在可视化中进行比较。
打开浏览器并导航到http://localhost:16686′′。 将服务下载菜单设置为服务并将限制结果更改为30`。
我们的应用程序的痕迹将出现在图表中:
在这里,我们看到服务的不同呼叫有不同的执行时间。Jaeger追踪了我们的应用程序处理信息所需的时间,以及哪些功能贡献的时间最长。请注意,由于我们的睡眠功能,我们完成hello_world()功能所需的时间是高度可变的。
通过实施跟踪和使用Jaeger UI,我们能够找到我们不规则响应时间的原因。
结论
在本文中,我们使用Jaeger设置了一个分布式跟踪系统,并将仪器添加到一个小型应用程序中。
通过分布式跟踪,在使用多个服务的应用程序中发现性能瓶颈要快得多,但是,这个例子只显示了Jaeger的潜力的一小部分。在更复杂的生产环境中,您可以使用Jaeger来比较不同的痕迹,并真正挖掘性能漏洞。