使用 Prometheus 和 Cloud Monitoring 监控在多个 GKE 集群上运行的应用

本教程首先介绍如何在多个运行于混合环境中的 Google Kubernetes Engine (GKE) 集群上部署 Prometheus 服务器,然后向您展示如何从在这些集群中运行的应用收集指标,并发送到 Cloud Monitoring 以便集中观察。

Prometheus 是受到 Google 内部监控系统 Borgmon 的影响所开发的一种开源监控和提醒工具包。Kubernetes 开源项目得到 Borg 的启发,而 Prometheus 则得到 Borgmon 的启发。这些工具能够很好地相互配合。

您可以使用 Prometheus 配置抓取目标,然后根据可配置的时间间隔查询(或抓取)这些目标,进而发现并拉取多组机器中的指标。抓取目标通常是从应用公开的 HTTP 端点,使用明确定义的说明格式且每一行说明一个指标。使用 HTTP 作为抓取目标的默认传输机制,即可从许多不同的语言和端点公开指标。从抓取目标收集而来的指标会存储在 Prometheus 的时间序列数据库中。

在生产环境中,您可以将指标从本地 Prometheus 数据库导出到更强大的监控解决方案,例如 Cloud Monitoring。Cloud Monitoring 是一个可监控和管理服务、容器、应用及基础架构的解决方案,由 Google 管理。Cloud Monitoring 针对指标、日志、跟踪记录和事件提供了安全可靠的存储解决方案。此外,它还提供了一套具有可观察性的工具,其中包括信息中心、报告、提醒及其他许多功能。

在本教程中,您将使用安装在多个 Kubernetes 集群上的 Prometheus 服务器来抓取应用 (PostgreSQL) 中的指标;您还将使用与 prometheus 容器一起运行的 prometheus-stackdriver-sidecar 容器,对指标进行验证并发送至 Monitoring 加以存储,以便用于分析和提醒。由于显示的 Sidecar 方法可将指标抓取与要监控的工作负载隔离开来,因此被视为最佳做法。这种方法可确保指标抓取和监控过程不会相互干扰,并且可以根据两者的需求分配资源。

在此解决方案中,您将在 Google Cloud 项目中构建以下架构。

架构图。

目标

  • 创建两个 GKE 集群,其中一个集群模拟非 Google Cloud Kubernetes 集群(例如,在本地运行的 Kubernetes 集群)。在本教程中,两个集群均为 GKE 集群。
  • 在这两个集群中安装 Prometheus 服务器。
  • 在这两个集群中配置 prometheus-stackdriver 导出器辅助容器。该辅助容器负责验证指标并将其发送至 Monitoring。
  • 在这两个集群中安装应用。本教程将 PostgreSQL 用作示例应用,但是,这种做法也适用于所有配置为导出 Prometheus 指标的应用。
  • 通过 Monitoring 监控从这两个集群中导出的指标。

费用

本教程使用 Google Cloud 的以下收费组件:

您可使用价格计算器根据您的预计使用量来估算费用。 Google Cloud 新用户可能有资格申请免费试用

准备工作

  1. 登录您的 Google 帐号。

    如果您还没有 Google 帐号,请注册一个新帐号

  2. 在 Cloud Console 的项目选择器页面上,选择或创建 Cloud 项目。

    转到项目选择器页面

  3. 确保您的 Google Cloud 项目已启用结算功能。 了解如何确认您的项目已启用结算功能

  4. 启用 GKE and Monitoring API。

    启用 API

完成本教程后,您可以删除所创建的资源以避免继续计费。如需了解详情,请参阅清理

设置环境

您将通过 Cloud Shell 运行本教程中的所有终端命令。

克隆存储库

  1. 打开 Cloud Shell:

    打开 Cloud Shell

  2. 克隆以下代码库,以下载本教程所需的文件。将代码库文件夹设为工作文件夹 ($WORKDIR),您将在这个文件夹中执行与本教程相关的所有任务。

    cd $HOME
    git clone https://github.com/GoogleCloudPlatform/prometheus-stackdriver-gke
    cd $HOME/prometheus-stackdriver-gke
    WORKDIR=$(pwd)
    

安装 Helm、kubectx 和 kubens

  1. 通过 Cloud Shell 在 $WORKDIR 文件夹中安装 Helm

    HELM_VERSION=v2.13.0
    HELM_PATH="$WORKDIR"/helm-"$HELM_VERSION"
    wget https://storage.googleapis.com/kubernetes-helm/helm-"$HELM_VERSION"-linux-amd64.tar.gz
    tar -xvzf helm-"$HELM_VERSION"-linux-amd64.tar.gz
    mv linux-amd64 "$HELM_PATH"
    rm $WORKDIR/helm-"$HELM_VERSION"-linux-amd64.tar.gz
    

    Helm 是一个软件包管理器,可用于配置和部署 Kubernetes 应用。此安装不会干扰您已安装的其他 Helm 安装项目。

  2. 安装 kubectxkubens

    git clone https://github.com/ahmetb/kubectx $WORKDIR/kubectx
    export PATH=$PATH:$WORKDIR/kubectx
    

    这些工具可让您更轻松地切换上下文环境和命名空间,有助于处理多个 GKE 集群。

安装 pgbench

在本教程中,您将使用 PostgreSQL 作为示例 Prometheus 监控应用。为了生成传入 PostgreSQL 的流量以便 Prometheus 服务器能够收集指标,您需要使用一个简单程序 pgbench 来对 PostgreSQL 运行基准测试。

  • 在 Cloud Shell 中安装 pgbench

    sudo apt-get install postgresql-contrib
    

配置 IAM

您可以创建 Identity and Access Management (IAM) 服务帐号,将权限委派给 Prometheus Sidecar 容器,以允许它将指标数据写入到 Monitoring 中。

  1. 在 Cloud Shell 中,创建一个供 Prometheus Monitoring 辅助容器使用的 Google Cloud 服务帐号:

    gcloud iam service-accounts create prometheus --display-name prometheus-service-account
    
  2. 将服务帐号电子邮件地址和您的当前项目 ID 存储在环境变量中,以供后续命令使用:

    export PROJECT_ID=$(gcloud info --format='value(config.project)')
    PROMETHEUS_SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:prometheus-service-account" \
        --format='value(email)')
    
  3. monitoring.metricWriter 角色绑定到该 Prometheus 服务帐号:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} --role roles/monitoring.metricWriter --member serviceAccount:${PROMETHEUS_SA_EMAIL}
    

    monitoring.metricWriter 角色可让 Prometheus 辅助容器将指标数据写入 Monitoring。Monitoring 会存储这些指标并将其用于信息中心、提醒等服务。

  4. 将服务帐号密钥下载到您的工作目录。

    gcloud iam service-accounts keys create $WORKDIR/prometheus-service-account.json --iam-account ${PROMETHEUS_SA_EMAIL}
    

Prometheus 辅助容器会使用该服务帐号密钥作为向 Cloud Monitoring API 进行身份验证的 Secret。

GKE 集群不会要求您手动配置这些密钥。在 GKE 中运行的 Pod(和容器)可访问 Compute Engine 实例元数据,并检索附加到 Prometheus 服务器运行所在 GKE 节点(或 Compute Engine 实例)的服务帐号信息。对于 GKE 集群,Prometheus 辅助容器可以使用实例元数据服务的服务帐号信息向 Cloud Monitoring API 进行身份验证。

非 GKE 集群(如在本地数据中心内运行的集群)无权访问 Google Cloud 服务帐号。此类集群需使用手动配置的服务帐号密钥向 Cloud Monitoring API 进行身份验证。

在本教程中,名为 gke 的 GKE 集群使用 Compute Engine 实例元数据向 Cloud Monitoring API 进行身份验证,以便写入指标。另一个名为 onprem 的 GKE 集群模拟非 GKE 集群;由于该集群无权访问 Monitoring API 来写入指标,因此您需要使用服务帐号密钥。

创建和配置 GKE 集群

GKE 节点是 Compute Engine 托管实例组,其中每个实例都拥有一个身份。Compute Engine 实例的身份就是该实例在创建时关联的 Google Cloud 服务帐号

与该服务帐号关联的 IAM 角色和权限也决定了与该实例关联的权限。如果您在创建 GKE 集群时没有明确定义服务帐号,系统就会使用项目的默认服务帐号创建集群。在集群中运行的 Pod 可以访问节点(Compute Engine 实例)的元数据服务,并使用关联的服务帐号访问各种 Google Cloud 服务,例如 Cloud Monitoring API。默认服务帐号和默认 GKE 范围具有将指标写入 Cloud Monitoring API 的权限。

在本教程中,您将使用默认服务帐号来创建 gkeonprem 两个集群。只有 gke 集群会使用 Compute Engine 实例元数据服务,并使用默认服务帐号将指标写入 Monitoring。onprem 集群则不使用默认服务帐号,而是使用 Prometheus Google Cloud 服务帐号密钥访问 Monitoring。

创建 GKE 集群

  1. us-west2-a 地区中创建第一个集群 gke,并在该集群上启用适用于 GKE 的 Cloud Monitoring

    gcloud beta container clusters create gke \
        --zone us-west2-a \
        --num-nodes 3 \
        --machine-type n1-standard-2 \
        --enable-stackdriver-kubernetes \
        --verbosity=none --async
    
  2. us-east4-a 地区中创建第二个集群 onprem

    gcloud container clusters create onprem \
        --zone us-east4-a \
        --num-nodes 3 \
        --machine-type n1-standard-2 \
        --verbosity=none
    
  3. 稍等几分钟,直到这两个集群都成功创建。确保两个集群都在运行:

    gcloud container clusters list
    

    输出类似于以下内容:

    NAME    LOCATION    MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
    onprem  us-east4-a  1.11.8-gke.6    <external IP>   n1-standard-2  1.11.8-gke.6  3          RUNNING
    gke     us-west2-a  1.11.8-gke.6    <external IP>   n1-standard-2  1.11.8-gke.6  3          RUNNING
    

配置集群连接和访问权限

  1. 连接到这两个集群,以在 kubeconfig 文件中生成相关条目:

    gcloud container clusters get-credentials gke --zone us-west2-a --project ${PROJECT_ID}
    gcloud container clusters get-credentials onprem --zone us-east4-a --project ${PROJECT_ID}
    

    kubeconfig 文件用于为每个集群创建用户和上下文环境信息,进而为集群创建身份验证。创建 kubeconfig 文件后,您就可以快速切换不同集群的上下文环境。

  2. 为方便起见,请使用 kubectx 重命名上下文名称:

    kubectx gke=gke_${PROJECT_ID}_us-west2-a_gke
    kubectx onprem=gke_${PROJECT_ID}_us-east4-a_onprem
    
  3. 向这两个集群授予您的 Google 身份 cluster-admin 权限,以便在这些集群上执行管理员级任务:

    kubectl create clusterrolebinding user-admin-binding \
        --clusterrole=cluster-admin \
        --user=$(gcloud config get-value account) \
              --context gke
    kubectl create clusterrolebinding user-admin-binding \
        --clusterrole=cluster-admin \
        --user=$(gcloud config get-value account) \
        --context onprem
    

安装和配置 Prometheus 服务器

在 GKE 集群和非 GKE 集群上配置 Prometheus 服务器时,工作流会有所不同。为避免混淆,本教程将分别介绍这两种设置。

在 GKE 集群上安装 Prometheus(GKE 工作流)

在本部分中,您将为 gke 集群配置 Prometheus。如果您运行的是 GKE 集群,请对每个集群执行以下工作流。

  1. 通过 Cloud Shell,在 gke 集群中为 Prometheus 创建一个专用命名空间:

    kubectl create namespace prometheus --context gke
    
  2. 创建 Prometheus Kubernetes 服务帐号、ClusterRole 角色和集群角色绑定:

    cd $WORKDIR
    kubectl apply -f prometheus-service-account.yaml --context gke
    

    集群角色会授予从所有命名空间中运行的部署检索指标的权限,而集群角色绑定会将此角色分配给 Prometheus 服务帐号。

  3. 创建 Prometheus configmap,从在 gke 集群中运行的应用抓取指标:

    kubectl apply -f prometheus-configmap.yaml --context gke
    

    如需详细了解 Prometheus 配置文件,请参阅 Prometheus 文档

    接下来,您需要创建 Prometheus 服务器部署。下一步中的清单将创建包含单个 pod 的 Prometheus 部署。该 pod 由两个容器组成:Prometheus 服务器容器和 Monitoring 辅助容器。Prometheus 服务器容器会从 GKE 集群中正在导出 Prometheus 指标的 pod 收集指标,然后使用 Monitoring 辅助容器将指标推送至 Monitoring。

  4. 定义在 Prometheus 部署清单中使用的环境变量:

    export KUBE_NAMESPACE=prometheus
    export KUBE_CLUSTER=gke
    export GCP_REGION=us-west2-a
    export GCP_PROJECT=$(gcloud info --format='value(config.project)')
    export DATA_DIR=/prometheus
    export DATA_VOLUME=prometheus-storage-volume
    export SIDECAR_IMAGE_TAG=release-0.3.2
    
  5. 使用您刚定义的环境变量应用 Prometheus 部署清单:

    envsubst < gke-prometheus-deployment.yaml | kubectl --context gke apply -f -
    
  6. 稍等片刻,然后确认 Prometheus pod 正在运行:

    kubectl get pods -n prometheus --context gke
    

    输出类似于以下内容:

    NAME                                     READY     STATUS    RESTARTS   AGE
    prometheus-deployment-6b5df7b5ff-ghqb2   2/2       Running   0          20s
    

    请注意,有两个容器正在 Prometheus pod 中运行。

  7. 验证容器映像:

    kubectl --context gke get pods -n prometheus -o json | jq '.items[].spec.containers[].image'
    

    输出类似于以下内容:

    "prom/prometheus:v2.6.1"
    "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
    

    您会看到 Prometheus 服务器和 stackdriver-prometheus-sidecar 容器正在 pod 中运行。

  8. 将端口转发设置为在 gke 集群中运行的 Prometheus 服务器界面:

    export PROMETHEUS_POD_GKE=$(kubectl get pods --namespace prometheus -l "app=prometheus-server" \
        -o jsonpath="{.items[0].metadata.name}" \
        --context gke)
    kubectl --context gke port-forward --namespace prometheus $PROMETHEUS_POD_GKE 9090:9090 >> /dev/null &
    

    下一步是开启 Prometheus 界面。

  9. 在 Cloud Shell 中,点击 Web 预览,然后点击更改端口

    1. 端口号中输入 9090
    2. 点击更改并预览。此时会显示 Prometheus 服务器界面。

    Prometheus 服务器界面。更改为端口 9090。

检查 gke 集群上的 Prometheus

Prometheus 会使用 Prometheus Kubernetes 服务帐号发现在 GKE 集群内运行的资源。其中部分资源已配置为导出 Prometheus 指标。

  1. 在 Prometheus 界面中,点击状态 (Status) > 服务发现 (Service Discovery)。显示的列表会列出 Prometheus 发现的 Kubernetes 资源。

    Prometheus 发现的 Kubernetes 资源。

    Service Discovery
    kubernetes-apiservers (1/16 active targets)
    kubernetes-cadvisor (3/3 active targets)
    kubernetes-nodes (3/3 active targets)
    kubernetes-pods (0/42 active targets)
    kubernetes-service-endpoints (0/16 active targets)
    
  2. 点击状态 (Status) > 目标 (Targets)。

    目标是在定期导出 Prometheus 指标的资源中定义的 HTTP(S) 端点。您会看到各种用于导出指标的 Kubernetes 资源,例如从 /metrics HTTPS 端点导出指标的 Kubernetes API 服务器。

gke 集群上安装 PostgreSQL

在本部分中,您将在 gke 集群上安装应用。该应用已设置插桩 (instrumentation),可导出 Prometheus 指标。在本教程中,您将使用稳定版 Helm Chart 来安装 PostgreSQL。不过,所有导出 Prometheus 指标的应用都遵循相同工作流。

  1. 切换到 gke 集群上下文:

    kubectx gke
    
  2. gke 集群中向 Helm 的服务器端 Tiller 授予 cluster-admin 角色:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding \
        --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. 初始化 Helm,并在 gke 集群中安装 Tiller:

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm repo update
    
  4. 运行以下命令来确保 Helm 已正确安装:

    ${HELM_PATH}/helm version
    

    输出类似于以下内容:

    Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    

    如果 Helm 已正确安装,则客户端和服务器都会显示 v2.13.0。您可能需要运行 version 命令多次,直到您看到客户端和服务器都已安装成功。

  5. 使用稳定版 Helm 安装 PostgreSQL:

    ${HELM_PATH}/helm install --name gke --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \
        stable/postgresql --set metrics.enabled=true \
        --set postgresqlDatabase=prometheusdb
    

    PostgreSQL 需要几分钟才能完成初始化。

  6. 确保 PostgreSQL 正在运行,然后再继续操作:

    kubectl get pods
    

    输出类似于以下内容:

    NAME               READY     STATUS    RESTARTS   AGE
    gke-postgresql-0   2/2       Running   0          1m
    

    检查在 PostgreSQL pod 中运行的两个容器:

    kubectl --context gke get pods gke-postgresql-0 -ojson | jq '.spec.containers[].image'
    

    输出类似于以下内容:

    "docker.io/bitnami/postgresql:10.7.0"
    "docker.io/wrouesnel/postgres_exporter:v0.4.7"
    

    第一个容器是 PostgreSQL 容器,第二个容器则是 Postgres 适用的 Prometheus 指标导出器。

  7. 检查在 gke 中运行的服务:

    kubectl get services
    

    输出类似于以下内容:

    NAME                      TYPE        CLUSTER-IP      EXTERNAL-IP
    gke-postgresql-metrics    ClusterIP   10.23.255.97    <none>        9187/TCP   1m
    

    PostgreSQL 会使用 gke-postgresql-metrics 服务公开 Prometheus 指标。

  8. 检查 gke-postgresql-metrics 服务中的注释:

    kubectl --context gke get service gke-postgresql-metrics -ojson | jq '.metadata.annotations'
    

    输出类似于以下内容:

    {
      "prometheus.io/port": "9187",
      "prometheus.io/scrape": "true"
    }
    

    Prometheus 会使用 Kubernetes 服务注册表来发现 Kubernetes 服务,并在这些服务中使用 Kubernetes 注释来确定 Prometheus 目标配置。这些注释描述了 Prometheus 配置,例如端口、目标端点、要抓取的服务以及其他设置。

    您会在输出结果中看到两个注释,它们描述了 Prometheus 指标的端口为 9187 以及 scrape 已设为 true。默认目标端点为 /metrics,除非另以注释加以定义。如需 Prometheus Kubernetes 注释和配置的详细列表,请参阅 Prometheus 文档

  9. 在 Prometheus 界面窗口中,点击或刷新状态 (Status) > 目标 (Targets) 页面,滚动至 kubernetes-service-endpoints 部分,然后点击 kubernetes-service-endpoints 链接旁边的展开 (show more):

    Prometheus 界面窗口。

    请注意 Prometheus 如何从端口为 9187 且抓取目标为 /metrics 的 PostgreSQL pod 抓取指标。IP 地址是该 PostgreSQL pod 的 IP 地址。

您已在 GKE 集群上成功安装了 Prometheus 服务器(具有 Monitoring 辅助容器),也安装了已正确配置为导出 Prometheus 指标的应用 (PostgreSQL)。Prometheus 正在通过 Kubernetes 服务注释从该应用中抓取指标。在下一部分中,您将在 onprem 集群上安装 Prometheus 和 PostgreSQL。

在 onprom 集群上安装 Prometheus(非 GKE 工作流)

在本部分中,您将为 onprem 集群配置 Prometheus。对于非 GKE 集群,请按照以下工作流操作。

  1. onprem 集群中为 Prometheus 创建一个专用命名空间:

    kubectl create namespace prometheus --context onprem
    
  2. 创建 Prometheus Kubernetes 服务帐号和 ClusterRole 角色:

    kubectl apply -f prometheus-service-account.yaml --context onprem
    

    ClusterRole 角色会向 Prometheus 服务器授予从在所有命名空间中运行的部署检索指标的权限。

  3. 创建 Prometheus configmap,从在 onprem 集群中运行的应用抓取指标:

    kubectl apply -f prometheus-configmap.yaml --context onprem
    

接下来,您需要创建 Prometheus 部署。Prometheus 服务器会使用名为 prometheus 的 Kubernetes 服务帐号(已在第 2 步中创建),从在 Kubernetes 集群中运行的应用抓取指标,并使用 Monitoring 辅助容器将这些指标发送到 Monitoring。辅助容器需要使用 Google Cloud 服务帐号向 Cloud Monitoring API 进行身份验证并推送指标。由于 onprem 集群模拟的是非 GKE 集群,因此它无法使用 Compute Engine 实例元数据服务访问 Google Cloud 服务帐号。如要配置辅助容器,请使用您之前下载的 Google Cloud 服务帐号 JSON 密钥。

以下步骤与您在 gke 集群上配置的 GKE 工作流不同。

  1. 使用 Google Cloud 服务帐号的 JSON 密钥创建 Secret:

    kubectl create secret -n prometheus generic prometheus-key --from-file=$WORKDIR/prometheus-service-account.json --context onprem
    
  2. 定义创建 Prometheus 部署所需的环境变量:

    export KUBE_NAMESPACE=prometheus
    export KUBE_CLUSTER=onprem
    export GCP_REGION=us-east4-a
    export GCP_PROJECT=$(gcloud info --format='value(config.project)')
    export DATA_DIR=/prometheus
    export DATA_VOLUME=prometheus-storage-volume
    export SIDECAR_IMAGE_TAG=release-0.3.2
    
  3. 创建 Prometheus 部署:

    envsubst < onprem-prometheus-deployment.yaml | kubectl --context onprem apply -f -
    
  4. 稍等片刻,然后确认 Prometheus pod 正在运行:

    kubectl get pods -n prometheus --context onprem
    

    输出类似于以下内容:

    NAME                                     READY     STATUS    RESTARTS   AGE
    prometheus-deployment-75857dc9fc-vp5cr   2/2       Running   0          55s
    

    请注意,有两个容器正在 Prometheus pod 中运行。

  5. 运行以下命令来验证容器映像。

    kubectl --context onprem get pods -n prometheus -ojson | jq '.items[].spec.containers[].image'
    

    输出类似于以下内容:

    "prom/prometheus:v2.6.1"
    "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
    

    您会看到 Prometheus 服务器和 stackdriver-prometheus-sidecar 容器正在 pod 中运行。Sidecar pod 使用 Secret (prometheus-key) 向 Cloud Stackdriver API 进行身份验证。请检查 Prometheus 部署的 volumesvolumeMountsenv

  6. 检查 Prometheus 部署中的 volumes

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.volumes'
    

    此命令会使用您之前创建的 secretName prometheus-key 来创建名为 prometheus-key 的卷。输出类似于以下内容:

      {
        "name": "prometheus-key",
        "secret": {
          "defaultMode": 420,
          "secretName": "prometheus-key"
        }
    
    
  7. 检查辅助容器上的 volumeMounts

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].volumeMounts'
    

    输出类似于以下内容:

    {
      "mountPath": "/var/secrets/google",
      "name": "prometheus-key"
    }
    

    prometheus-key 会装载在 stackdriver-sidecar 容器的装载路径 /var/secrets/google 中。此路径是服务帐号密钥所在的位置。

  8. 检查为 Monitoring 辅助容器定义的环境变量。环境变量 [GOOGLE_APPLICATION_CREDENTIALS](/docs/authentication/getting-started#setting_the_environment_variable) 是 Google 客户端库用于身份验证的特殊环境变量。系统会为此变量分配指向 prometheus-service-account.json 密钥路径的值。Monitoring 辅助容器使用 Google 客户端库,因此会通过此变量向 Cloud Monitoring API 进行身份验证。

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].env'
    

    输出类似于以下内容:

    [
      {
        "name": "GOOGLE_APPLICATION_CREDENTIALS",
        "value": "/var/secrets/google/prometheus-service-account.json"
      }
    ]
    
  9. 将端口转发设置为在 onprem 集群中运行的 Prometheus 服务器界面:

    export PROMETHEUS_POD_ONPREM=$(kubectl get pods --namespace prometheus -l "app=prometheus-server" \
        -o jsonpath="{.items[0].metadata.name}" --context onprem)
    kubectl --context onprem port-forward \
        --namespace prometheus $PROMETHEUS_POD_ONPREM 9091:9090 >> /dev/null &
    

    下一步是开启 Prometheus 界面

  10. 在 Cloud Shell 中,点击 Web 预览,然后点击更改端口

    1. 端口号中输入 9091
    2. 点击更改并预览。此时会显示 Prometheus 服务器界面。这可确认 Prometheus 服务器正在运行。

    Prometheus 界面。将端口号更改为 9091。

在 onprem 集群上安装 PostgreSQL

在本部分中,您将使用 Helm 在 onprem 集群上安装 PostgreSQL。以下步骤与 gke 集群的 PostgreSQL 安装过程相同。

  1. 切换到 onprem 上下文:

    kubectx onprem
    
  2. onprem 集群中向 Helm 的服务器端 Tiller 授予 cluster-admin 角色:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. 初始化 Helm,并在 onprem 集群中安装 Tiller:

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm update
    

    运行以下命令来确保 Helm 已正确安装:

    ${HELM_PATH}/helm version
    

    如果 Helm 已正确安装,则客户端和服务器都会显示 v2.13.0。您可能需要运行该命令多次,直到您看到客户端和服务器都已安装成功。

    Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    
  4. 使用稳定版 Helm 安装 PostgreSQL:

    ${HELM_PATH}/helm install --name onprem \
    --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \
    stable/postgresql --set metrics.enabled=true --set postgresqlDatabase=prometheusdb
    
  5. 确保 PostgreSQL 正在运行:

    kubectl get pods
    

    输出类似于以下内容:

    onprem-postgresql-0   2/2       Running   0          39s
    

    检查 PostgreSQL pod 中运行的两个容器:

    kubectl --context onprem get pods onprem-postgresql-0 -ojson | jq '.spec.containers[].image'
    

    第一个容器是 PostgreSQL 容器,第二个容器则是 Postgres 适用的 Prometheus 指标导出器。输出类似于以下内容:

    "docker.io/bitnami/postgresql:10.7.0"
    "docker.io/wrouesnel/postgres_exporter:v0.4.7"
    
  6. 检查在 onprem 集群中运行的服务。PostgreSQL 会使用 onprem-postgresql-metrics 服务公开 Prometheus 指标。

    kubectl get services --context onprem
    

    输出类似于以下内容:

    onprem-postgresql-metrics    ClusterIP   10.47.240.77    <none>        9187/TCP   1m
    
  7. 检查 onprem-postgresql-metrics 服务中的注释。

    kubectl --context onprem get service onprem-postgresql-metrics -ojson | jq '.metadata.annotations'
    

    输出类似于以下内容:

    {
      "prometheus.io/port": "9187",
      "prometheus.io/scrape": "true"
    }
    
  8. 在 Prometheus 界面窗口中,点击状态 (Status) > 目标 (Targets) 页面,滚动至 kubernetes-service-endpoints 部分,然后点击 kubernetes-service-endpoints 链接旁边的展开 (show more) 按钮:

    Prometheus 抓取指标。

    Prometheus 正在从端口为 9187 且抓取目标为 /metrics 的 PostgreSQL pod 抓取指标。

您已在非 GKE 集群(例如在本地数据中心内运行的 Kubernetes 集群)上成功安装了 Prometheus 服务器(具有辅助容器),还在该集群中安装了已正确配置为导出 Prometheus 指标的 PostgreSQL。Prometheus 正在通过 Kubernetes 服务注释从 PostgreSQL 数据库中抓取指标。

在下一部分中,您将设置 Monitoring 的监控功能,为在 gkeonprem 集群中运行的 PostgreSQL 数据库生成传入流量,并通过 Monitoring 监控指标。

设置监控功能

在本部分中,您将在 Monitoring 中设置用于监控指标的新工作区。工作区会整理 Monitoring 中的监控信息。您可以通过 Monitoring 工作区监控任意位置的重要资源。如需为 Google Cloud 项目创建工作区,您必须拥有该项目的以下某个 IAM 角色:

  • Project Owner
  • Monitoring Editor
  • Monitoring Admin
  • Monitoring Accounts Editor

如需在 Monitoring 中设置指标,请执行以下操作:

  1. 在 Google Cloud Console 中,转到 Monitoring 或使用以下按钮:

    转到 Monitoring

  2. 首次点击 Monitoring 链接时,系统会自动创建并初始化一个新的工作区。工作区名称与项目 ID 相同。

  3. 点击信息中心
  4. 点击创建信息中心
  5. 信息中心名称字段中,输入 PostgreSQL
  6. 点击添加图表
  7. 确保所选标签页为指标
  8. 点击查找资源类型和指标 (Find resource type and metric) 对应的框,然后输入 pg_stat_database_blks_read
  9. 分组依据下拉列表中,选择 cluster_name
  10. 对于聚合器,输入 sum

    查找资源类型。

    请注意,指标名称的前缀为 external/prometheus/。这表示指标来自 Prometheus 服务器。在图表中,您会看到来自两个集群的指标,这表示 gkeonprem 集群都在导出指标。

  11. 点击保存图表。并为图表命名。
  12. 点击添加图表
  13. 对于此图表,请输入指标 pg_stat_database_blks_hit
  14. 分组依据下拉列表中,选择 cluster_name
  15. 对于聚合器,输入 sum
  16. 点击保存图表。并为图表命名。
  17. 点击信息中心,然后选择 PostgreSQL。此信息中心内有两个图表。
  18. 点击 列表图标即可查看图例,并确认您正在接收来自两个集群的指标。

    确认您正在接收来自两个集群的指标。

    您也可以点击信息中心内的添加图表,通过信息中心添加指标。

为 PostgreSQL 生成传入流量

在本部分中,您将为在两个集群中运行的 PostgreSQL 数据库生成传入流量,以监控 Monitoring 信息中心内的指标。您将使用 PostgreSQL 基准测试工具 pgbench 来生成流量,并使用两个 Cloud Shell 窗口同时为这两个 PostgreSQL 数据库生成传入流量。

为 GKE PostgreSQL 实例生成传入流量

  1. 在顶部栏的 Cloud Shell 标签页旁边,打开第二个 Cloud Shell 标签页:

    打开第二个 Cloud Shell 会话。

    在第一个 Cloud Shell 窗口中运行以下命令,为在 gke 集群中运行的 PostgreSQL 数据库生成传入流量。

  2. 获取 gke 集群中的 PostgreSQL 数据库密码:

    export POSTGRES_PASSWORD_GKE=$(kubectl --context gke get secret --namespace default gke-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  3. 使用端口转发公开 gke 集群中端口为 5432 的 PostgreSQL 数据库:

    kubectl --context gke port-forward --namespace default svc/gke-postgresql 5432:5432 >> /dev/null &
    
  4. 登录该 PostgreSQL 数据库:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" psql --host 127.0.0.1 -p 5432 -U postgres -d prometheusdb
    
  5. 创建名为 gketest 的数据库以进行基准测试:

    CREATE DATABASE gketest;
    
  6. 退出该 PostgreSQL 数据库:

    \q
    
  7. 初始化 gketest 数据库以进行基准测试:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -i -h localhost -p 5432 -U postgres -d gketest
    
  8. gke 集群中的 gketest 数据库启动基准测试。以下测试会依照 -T 选项(以秒为单位)的配置运行 10 分钟。

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -c 10 -T 600 -h localhost -p 5432 -U postgres -d gketest
    

onprem PostgreSQL 实例生成传入流量

在第二个 Cloud Shell 窗口中运行以下命令,为在 onprem 集群中运行的 PostgreSQL 数据库生成传入流量。

  1. 获取 onprem 集群中的 PostgreSQL 数据库密码:

    export POSTGRES_PASSWORD_ONPREM=$(kubectl --context onprem get secret --namespace default onprem-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  2. 使用端口转发公开 onprem 集群中端口为 5431 的 PostgreSQL 数据库:

    kubectl --context onprem port-forward --namespace default svc/onprem-postgresql 5431:5432 >> /dev/null &
    
  3. 登录该 PostgreSQL 数据库:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" psql --host 127.0.0.1 -p 5431 -U postgres -d prometheusdb
    
  4. 创建名为 onpremtest 的数据库以进行基准测试:

    CREATE DATABASE onpremtest;
    
  5. 退出该 PostgreSQL 数据库。

    \q
    
  6. 初始化 onpremtest 数据库以进行基准测试:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -i -h localhost -p 5431 -U postgres -d onpremtest
    
  7. onprem 集群中的 onpremtest 数据库启动基准测试。以下测试会运行 10 分钟。

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -c 10 -T 600 -h localhost -p 5431 -U postgres -d onpremtest
    

查看监控数据

测试运行期间,您可以返回 Monitoring 页面并检查图表。

  1. 在 Cloud Console 中,转到 Monitoring

    转到 Monitoring

    从在多个集群上运行的应用接收 Prometheus 指标。

  2. 转到信息中心 > PostgreSQL

  3. 如要启用自动刷新功能,请点击自动刷新 。几分钟后,系统就会将数据库块读取和命中数据填入图表中。

您现在正从运行于多个 Kubernetes 集群上的应用接收 Prometheus 指标,并推送至 Monitoring。

清理

为避免因本教程中使用的资源而导致您的 Google Cloud Platform 帐号产生费用,请执行以下操作:

删除项目

  1. 在 Cloud Console 中,转到管理资源页面。

    转到“管理资源”页面

  2. 在项目列表中,选择要删除的项目,然后点击删除
  3. 在对话框中输入项目 ID,然后点击关闭以删除项目。

后续步骤