Kubernetes权威指南——Kubernetes集群管理（五）

关注

原创 2026-11-10 21:38:22 125 阅读 AI 写同款· GEO 优化 ›

零基础学kubernetes（k8s）必看教程，带你10分钟快速实战入门k8s 作为一个工作十余年，拥有比较丰富的计算机网络运维、主机运维、云计算平台运维、自动化运维开发经验的老鸟，我来说说我当初刚接触Kubernetes时的一些感受以及学习技巧。阅读详情

Kubernetes集群管理

8、Kubernetes集群监控

Kubernetes的早期版本依靠Heapster来实现完整的性能数据采集和监控功能，Kubernetes从1.8版本开始，性能数据开始以Metrics API的方式提供标准化接口，并且从1.10版本开始将Heapster替换为Metrics Server。在Kubernetes新的监控体系中，Metrics Server用于提供核心指标（Core Metrics），包括Node、Pod的CPU和内存使用指标。对其他自定义指标（Custom Metrics）的监控则由Prometheus等组件来完成。

8.1、通过Metrics Server监控Pod和Node的CPU和内存资源使用数据

Metrics Server在部署完成后，将通过Kubernetes核心API Server的“/apis/metrics.k8s.io/v1beta1”路径提供Pod和Node的监控数据。Metrics Server源代码和部署配置可以在GitHub代码库（https://github.com/kubernetes-incubator/metrics-server）找到。

首先，部署Metrics Server实例，在下面的YAML配置中包含ServiceAccount、Deployment和Service的定义：

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: metrics-server
  namespace: kube-system
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: metrics-server
  namespace: kube-system
  labels:
    k8s-app: metrics-server
spec:
  selector:
    matchLabels:
      k8s-app: metrics-server
  template:
    metadata:
      name: metrics-server
      labels:
        k8s-app: metrics-server
    spec:
      serviceAccountName: metrics-server
      containers:
        - name: metrics-server
          image: k8s.gcr.io/metrics-server-amd64:v0.3.1
          imagePullPolicy: IfNotPresent
          volumeMounts:
            - name: tmp-dir
              mountPath: /tmp
      volumes:
        - name: tmp-dir
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: metrics-server
  namespace: kube-system
  labels:
    kubernetes.io/name: "Metrics-server"
spec:
  selector:
    k8s-app: metrics-server
  ports:
    - port: 443
      protocol: TCP
      targetPort: 443

然后，创建metrics-server所需的RBAC权限配置，此处略。

最后，创建APIService资源，将监控数据通过“/apis/metrics.k8s.io/v1beta1”路径提供：

apiVersion: apiregistration.k8s.io/v1beta1
kind: APIService
metadata:
  # APIService 的标准命名规范通常为 “version.group”
  name: v1beta1.metrics.k8s.io
spec:
  # 后端实际提供该 API 服务的 Kubernetes Service 信息
  service:
    name: metrics-server        # 后端服务的名称
    namespace: kube-system      # 后端服务所在的命名空间
  
  # API 组名称
  group: metrics.k8s.io
  # API 版本
  version: v1beta1
  
  # 是否跳过 TLS 证书验证（测试或简化配置时常用，生产环境建议配置受信任的 CA 证书）
  insecureSkipTLSVerify: true
  
  # 优先级设置：决定同一 Group 中多个版本或服务的优先级顺序
  groupPriorityMinimum: 100
  versionPriority: 100

在部署完成后确保metrics-server的Pod启动成功：

# kubectl -n kube-system get pod -l k8s-app=metrics-server
NAME                                        READY   STATUS    RESTARTS   AGE
metrics-server-7cb798c45b-4dnmh            1/1     Running   0          5m

使用kubectl top nodes和kubectl top pods命令监控CPU和内存资源的使用情况：

# kubectl top nodes
NAME         CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
k8s-node-1   319m         7%     1167Mi          67%

# kubectl top pods --all-namespaces
NAMESPACE     NAME                                        CPU(cores)   MEMORY(bytes)
kube-system   coredns-767997f5b5-sfz2w                   6m           36Mi
kube-system   metrics-server-7cb798c45b-4dnmh            3m           22Mi
......

Metrics Server提供的数据也可以供HPA控制器使用，以实现基于CPU使用率或内存使用值的Pod自动扩缩容功能。

8.2、Prometheus+Grafana集群性能监控平台搭建

Prometheus是由SoundCloud公司开发的开源监控系统，是继Kubernetes之后CNCF第2个毕业的项目，在容器和微服务领域得到了广泛应用。Prometheus的主要特点如下。

使用指标名称及键值对标识的多维度数据模型。
采用灵活的查询语言PromQL。
不依赖分布式存储，为自治的单节点服务。
使用HTTP完成对监控数据的拉取。
支持通过网关推送时序数据。
支持多种图形和Dashboard的展示，例如Grafana。

Prometheus生态系统由各种组件组成，用于功能的扩充。

Prometheus Server：负责监控数据采集和时序数据存储，并提供数据查询功能。
客户端SDK：对接Prometheus的开发工具包。
Push Gateway：推送数据的网关组件。
第三方Exporter：各种外部指标收集系统，其数据可以被Prometheus采集。
AlertManager：告警管理器。
其他辅助支持工具。

Prometheus的核心组件Prometheus Server的主要功能包括：从Kubernetes Master获取需要监控的资源或服务信息；从各种Exporter抓取（Pull）指标数据，然后将指标数据保存在时序数据库（TSDB）中；向其他系统提供HTTP API进行查询；提供基于PromQL语言的数据查询；可以将告警数据推送（Push）给AlertManager，等等。

Prometheus的系统架构如图所示。
在这里插入图片描述
在部署Prometheus时可以直接基于官方提供的镜像进行，也可以通过Operator模式进行。本文以直接部署为例，Operator模式的部署案例可以参考3.12.2节的示例。

下面对部署Prometheus服务的过程进行说明。

首先，创建一个ConfigMap用于保存Prometheus的主配置文件prometheus.yml，其中可以配置需要监控的Kubernetes集群的资源对象或服务（如Service、Pod、Node等）：

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: kube-system
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: EnsureExists
data:
  prometheus.yml: |
    global:
      scrape_interval: 30s
    scrape_configs:
      - job_name: prometheus
        static_configs:
          - targets:
              - localhost:9090

      - job_name: kubernetes-apiservers
        kubernetes_sd_configs:
          - role: endpoints
        relabel_configs:
          - action: keep
            regex: default;kubernetes;https
            source_labels:
              - __meta_kubernetes_namespace
              - __meta_kubernetes_service_name
              - __meta_kubernetes_endpoint_port_name
        scheme: https
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
          insecure_skip_verify: true
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token

      - job_name: kubernetes-nodes-kubelet
        # 此处可根据实际需求补充对应节点的抓取规则
        
      - job_name: kubernetes-service-endpoints
        # 此处可补充服务端点抓取规则
        
      - job_name: kubernetes-services
        # 此处可补充集群 Service 抓取规则
        
      - job_name: kubernetes-pods
        # 此处可补充 Pod 指标抓取规则

接下来部署Prometheus Deployment和Service：

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus
  namespace: kube-system
  labels:
    k8s-app: prometheus
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: prometheus
  template:
    metadata:
      labels:
        k8s-app: prometheus
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      priorityClassName: system-cluster-critical
      # 初始化容器：用于调整数据目录的属主权限（确保非 root 运行的 prometheus 有权写入 /data）
      initContainers:
        - name: "init-chown-data"
          image: "busybox:latest"
          imagePullPolicy: "IfNotPresent"
          command: ["chown", "-R", "65534:65534", "/data"]
          volumeMounts:
            - name: storage-volume
              mountPath: /data
              subPath: ""
      containers:
        # 辅助容器：监控 ConfigMap 变化并自动热重载 Prometheus 配置
        - name: prometheus-server-configmap-reload
          image: "jimmidyson/configmap-reload:v0.1"
          imagePullPolicy: "IfNotPresent"
          args:
            - --volume-dir=/etc/config
            - --webhook-url=http://localhost:9090/-/reload
          volumeMounts:
            - name: config-volume
              mountPath: /etc/config
              readOnly: true
        # Prometheus 主容器
        - name: prometheus-server
          image: "prom/prometheus:v2.8.0"
          imagePullPolicy: "IfNotPresent"
          args:
            - --config.file=/etc/config/prometheus.yml
            - --storage.tsdb.path=/data
            - --web.console.libraries=/etc/prometheus/console_libraries
            - --web.console.templates=/etc/prometheus/consoles
            - --web.enable-lifecycle
          ports:
            - containerPort: 9090
          readinessProbe:
            httpGet:
              path: /-/ready
              port: 9090
            initialDelaySeconds: 30
            timeoutSeconds: 30
          livenessProbe:
            httpGet:
              path: /-/healthy
              port: 9090
            initialDelaySeconds: 30
            timeoutSeconds: 30
          volumeMounts:
            - name: config-volume
              mountPath: /etc/config
            - name: storage-volume
              mountPath: /data
              subPath: ""
      terminationGracePeriodSeconds: 300
      volumes:
        - name: config-volume
          configMap:
            name: prometheus-config
        - name: storage-volume
          hostPath:
            path: /prometheus-data
            type: Directory
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: kube-system
  labels:
    kubernetes.io/name: "Prometheus"
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  type: NodePort
  ports:
    - name: http
      port: 9090
      nodePort: 9090
      protocol: TCP
      targetPort: 9090
  selector:
    k8s-app: prometheus

在部署完成后，确保Prometheus运行成功：

# kubectl -n kube-system get pods -l k8s-app=prometheus
NAME                              READY   STATUS    RESTARTS   AGE
prometheus-5fbb5ddd4f-2wrxj   2/2     Running   0          3m32s

Prometheus提供了一个简单的Web页面用于查看已采集的监控数据，上面的Service定义了NodePort为9090，我们可以通过访问Node的9090端口访问这个页面，如图所示。
在这里插入图片描述
在Prometheus提供的Web页面上，可以输入PromQL查询语句对指标数据进行查询，也可以选择一个指标进行查看，例如选择container_network_receive_bytes_total指标查看容器的网络接收字节数，如图所示。

在这里插入图片描述
单击Graph标签，可以查看该指标的时序图，如图所示。

接下来可以针对各种系统和服务部署各种Exporter进行指标数据的采集。目前Prometheus支持多种开源软件的Exporter，包括数据库、硬件系统、消息系统、存储系统、HTTP服务器、日志服务，等等，可以从Prometheus的官网https://prometheus.io/docs/instrumenting/exporters/获取各种Exporter的信息。

下面以官方维护的node_exporter为例进行部署。node_exporter主要用于采集主机相关的性能指标数据，其官网为https://github.com/prometheus/node_exporter。node_exporter的YAML配置文件如下：

---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-exporter
  namespace: kube-system
  labels:
    k8s-app: node-exporter
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    version: v0.17.0
spec:
  selector:
    matchLabels:
      k8s-app: node-exporter
  updateStrategy:
    type: OnDelete
  template:
    metadata:
      labels:
        k8s-app: node-exporter
        version: v0.17.0
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      priorityClassName: system-node-critical
      # 开启宿主机网络与 PID 命名空间，以便直接读取宿主机的系统状态
      hostNetwork: true
      hostPID: true
      containers:
        - name: prometheus-node-exporter
          image: "prom/node-exporter:v0.17.0"
          imagePullPolicy: "IfNotPresent"
          args:
            - --path.procfs=/host/proc
            - --path.sysfs=/host/sys
          ports:
            - name: metrics
              containerPort: 9100
              hostPort: 9100
          volumeMounts:
            - name: proc
              mountPath: /host/proc
              readOnly: true
            - name: sys
              mountPath: /host/sys
              readOnly: true
          resources:
            limits:
              cpu: 1
              memory: 512Mi
            requests:
              cpu: 100m
              memory: 50Mi
      volumes:
        - name: proc
          hostPath:
            path: /proc
        - name: sys
          hostPath:
            path: /sys
---
apiVersion: v1
kind: Service
metadata:
  name: node-exporter
  namespace: kube-system
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "9100"
    prometheus.io/path: "/metrics"
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "NodeExporter"
spec:
  # Headless Service：不分配 Cluster IP，直接通过 Pod IP 列表进行抓取
  clusterIP: None
  ports:
    - name: metrics
      port: 9100
      protocol: TCP
      targetPort: 9100
  selector:
    k8s-app: node-exporter

在部署完成后，在每个Node上都运行了一个node-exporter Pod：

# kubectl -n kube-system get pods -l k8s-app: node-exporter
NAME                                        READY   STATUS    RESTARTS   AGE
node-exporter-2x4fq                        1/1     Running   0          15m
node-exporter-saz2w                        1/1     Running   0          15m
node-exporter-kr8wc                        1/1     Running   0          15m
......

从Prometheus的Web页面就可以查看node-exporter采集的Node指标数据了，如图所示。
在这里插入图片描述最后，部署Grafana用于展示专业的监控页面，其YAML配置文件如下：

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: grafana
  namespace: kube-system
  labels:
    k8s-app: grafana
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: grafana
  template:
    metadata:
      labels:
        k8s-app: grafana
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ''
    spec:
      priorityClassName: system-cluster-critical
      # 容忍 Master 节点的污点，允许 Grafana 调度到控制平面节点上运行
      tolerations:
        - key: node-role.kubernetes.io/master
          effect: NoSchedule
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      containers:
        - name: grafana
          image: grafana/grafana:6.0.1
          imagePullPolicy: IfNotPresent
          resources:
            limits:
              cpu: 1
              memory: 1Gi
            requests:
              cpu: 100m
              memory: 100Mi
          env:
            - name: GF_AUTH_BASIC_ENABLED
              value: "false"
            - name: GF_AUTH_ANONYMOUS_ENABLED
              value: "true"
            - name: GF_AUTH_ANONYMOUS_ORG_ROLE
              value: Admin
            - name: GF_SERVER_ROOT_URL
              value: /api/v1/namespaces/kube-system/services/grafana/proxy/
          ports:
            - name: ui
              containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: grafana
  namespace: kube-system
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
    kubernetes.io/name: "Grafana"
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: ui
  selector:
    k8s-app: grafana

部署完成后，通过Kubernetes Master的URL访问Grafana页面，例如http://192.168.18.3:8080/api/v1/namespaces/kube-system/services/grafana/proxy。

在Grafana的设置页面添加类型为Prometheus的数据源，输入Prometheus服务的URL（如http://prometheus:9090）进行保存，如图所示。
在这里插入图片描述

在Grafana的Dashboard控制面板导入预置的Dashboard模板，以显示各种监控图表。Grafana官网（https://grafana.com/dashboards）提供了许多针对Kubernetes集群监控的Dashboard模板，可以下载、导入并使用。下图显示了一个可以监控集群CPU、内存、文件系统、网络吞吐率的Dashboard。

在这里插入图片描述

至此，基于Prometheus+Grafana的Kubernetes集群监控系统就搭建完成了。

9、集群统一日志管理

在Kubernetes集群环境中，一个完整的应用或服务都会涉及为数众多的组件运行，各组件所在的Node及实例数量都是可变的。日志子系统如果不做集中化管理，则会给系统的运维支撑造成很大的困难，因此有必要在集群层面对日志进行统一收集和检索等工作。

在容器中输出到控制台的日志，都会以*-json.log的命名方式保存在/var/lib/docker/containers/目录下，这就为日志采集和后续处理奠定了基础。

Kubernetes推荐采用Fluentd+Elasticsearch+Kibana完成对系统和容器日志的采集、查询和展现工作。

部署统一的日志管理系统，需要以下两个前提条件。

API Server正确配置了CA证书。
DNS服务启动、运行。

9.1、系统部署架构

该系统的逻辑架构如图所示。
在这里插入图片描述
在各Node上都运行了一个Fluentd容器，采集本节点/var/log和/var/lib/docker/containers两个目录下的日志进程，将其汇总到Elasticsearch集群，最终通过Kibana完成和用户的交互工作。

这里有一个特殊的需求：Fluentd必须在每个Node上运行。为了满足这一需求，我们通过以下几种方式部署Fluentd。

直接在Node主机上部署Fluentd。
利用kubelet的–config参数，为每个Node都加载Fluentd Pod。
利用DaemonSet让Fluentd Pod在每个Node上运行。

9.2、创建Elasticsearch RC和Service

Elasticsearch的RC和Service定义如下：

---
apiVersion: v1
kind: ReplicationController
metadata:
  name: elasticsearch-logging-v1
  namespace: kube-system
  labels:
    k8s-app: elasticsearch-logging
    version: v1
    kubernetes.io/cluster-service: "true"
spec:
  replicas: 2
  selector:
    k8s-app: elasticsearch-logging
    version: v1
  template:
    metadata:
      labels:
        k8s-app: elasticsearch-logging
        version: v1
        kubernetes.io/cluster-service: "true"
    spec:
      containers:
        - name: elasticsearch-logging
          image: gcr.io/google_containers/elasticsearch:1.8
          resources:
            # 保持 requests 与 limits 相等，使该容器处于 Guaranteed（保证型）QoS 级别
            limits:
              cpu: 100m
            requests:
              cpu: 100m
          ports:
            - containerPort: 9200
              name: db
              protocol: TCP
            - containerPort: 9300
              name: transport
              protocol: TCP
          volumeMounts:
            - name: es-persistent-storage
              mountPath: /data
      volumes:
        - name: es-persistent-storage
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: elasticsearch-logging
  namespace: kube-system
  labels:
    k8s-app: elasticsearch-logging
    kubernetes.io/cluster-service: "true"
    kubernetes.io/name: "Elasticsearch"
spec:
  ports:
    - port: 9200
      protocol: TCP
      targetPort: db
  selector:
    k8s-app: elasticsearch-logging

执行kubectl create -f elastic-search.yml命令完成创建。

在命令成功执行后，首先验证Pod的运行情况。通过kubectl get pods–namespaces=kube-system获取运行中的Pod：

# kubectl get pods --namespaces=kube-system
NAMESPACE     NAME                                   READY    STATUS   RESTARTS  AGE
kube-system   elasticsearch-logging-v1-59qvp      1/1     Running   0      18h
kube-system   elasticsearch-logging-v1-xnv14      1/1     Running   0      18h

接下来通过Elasticsearch页面验证其功能。

首先，执行# kubectl cluster-info命令获取Elasticsearch服务的地址：

# kubectl cluster-info
Elasticsearch is running at
http://192.168.18.3:8080/api/v1/proxy/namespaces/kube-system/services/elasticsea
rch-logging

然后，使用# kubectl proxy命令对API Server进行代理，在成功执行后输出如下内容：

# kubectl proxy
Starting to serve on 127.0.0.1:8001

这样就可以在浏览器上访问URL地址http://192.168.18.3:8001/api/v1/proxy/namespaces/kube-system/services/elasticsearch-logging，来验证Elasticsearch的运行情况了，返回的内容是一个JSON文档：

{
"status": 200,
"name": "Emplate",
"cluster_name": "kubernetes-logging",
"version": {
"number": "1.5.2",
"build_hash": "62ff9868b4c8a0c45860bebb259e21980778ab1c",
"build_timestamp": "2015-04-27T09:21:06Z",
"build_snapshot": false,
"lucene_version": "4.10.4"
},
"tagline": "You Know, for Search"
}

9.3、在每个Node上启动Fluentd

Fluentd的DaemonSet定义如下：

---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd-cloud-logging
  namespace: kube-system
  labels:
    k8s-app: fluentd-cloud-logging
spec:
  selector:
    matchLabels:
      k8s-app: fluentd-cloud-logging
  template:
    metadata:
      namespace: kube-system
      labels:
        k8s-app: fluentd-cloud-logging
    spec:
      tolerations:
        - operator: Exists
          effect: NoSchedule
      containers:
        - name: fluentd-cloud-logging
          image: gcr.io/google_containers/fluentd-elasticsearch:1.17
          resources:
            limits:
              cpu: 100m
              memory: 200Mi
          env:
            - name: FLUENTD_ARGS
              value: -q
          volumeMounts:
            - name: varlog
              mountPath: /var/log
              readOnly: false
            - name: containers
              mountPath: /var/lib/docker/containers
              readOnly: true
      volumes:
        - name: containers
          hostPath:
            path: /var/lib/docker/containers
        - name: varlog
          hostPath:
            path: /var/log

通过kubectl create命令创建Fluentd容器：

# kubectl create -f fluentd-ds.yml

查看创建的结果：

# kubectl get daemonset
NAME                         DESIRED  CURRENT   NODE-SELECTOR   AGE
fluentd-cloud-logging    3          3          <none>           1h

# kubectl get pods
NAMESPACE     NAME                      READY     STATUS    RESTARTS   AGE
fluentd-cloud-logging-7tw9z           1/1       Running    0          18h
fluentd-cloud-logging-aqdn1           1/1       Running    0          18h
fluentd-cloud-logging-o4usx           1/1       Running    0          18h

结果显示Fluentd DaemonSet正常运行，还启动了3个Pod，与集群中的Node数量一致。

接下来使用# kubectl logs fluentd-cloud-logging-7tw9z命令查看Pod的日志，在Elasticsearch正常工作的情况下，我们会看到类似下面这样的日志内容：

# kubectl logs fluentd-cloud-logging-7tw9z
Connection opened to Elasticsearch cluster =>
{:host=>"elasticsearch-logging", :port=>9200, :scheme=>"http"}

说明Fluentd与Elasticsearch已经正确建立了连接。

9.4、运行Kibana

至此已经运行了Elasticsearch和Fluentd，数据的采集和汇聚已经完成，接下来使用Kibana展示和操作数据。

Kibana的RC和Service定义如下：

---
apiVersion: v1
kind: ReplicationController
metadata:
  name: kibana-logging-v1
  namespace: kube-system
  labels:
    k8s-app: kibana-logging
    version: v1
    kubernetes.io/cluster-service: "true"
spec:
  replicas: 1
  selector:
    k8s-app: kibana-logging
    version: v1
  template:
    metadata:
      labels:
        k8s-app: kibana-logging
        version: v1
        kubernetes.io/cluster-service: "true"
    spec:
      containers:
        - name: kibana-logging
          image: gcr.io/google_containers/kibana:1.3
          resources:
            # 保持 requests 与 limits 相等，使该容器处于 Guaranteed（保证型）QoS 级别
            limits:
              cpu: 100m
            requests:
              cpu: 100m
          env:
            - name: "ELASTICSEARCH_URL"
              value: "http://elasticsearch-logging:9200"
          ports:
            - containerPort: 5601
              name: ui
              protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: kibana-logging
  namespace: kube-system
  labels:
    k8s-app: kibana-logging
    kubernetes.io/cluster-service: "true"
    kubernetes.io/name: "Kibana"
spec:
  ports:
    - port: 5601
      protocol: TCP
      targetPort: ui
  selector:
    k8s-app: kibana-logging

通过kubectl create -f kibana-rc-svc.yml命令创建Kibana的RC和Service：

# kubectl create -f kibana-rc-svc.yml
replicationcontroller "kibana-logging-v1" created
service "kibana-logging" created

查看Kibana的运行情况：

# kubectl get pods
NAMESPACE   NAME                         READY     STATUS    RESTARTS   AGE
default     kibana-logging-v1-o1akg   1/1       Running   0           1h
    # kubectl get svc
    NAME               CLUSTER-IP         EXTERNAL-IP   PORT(S)    AGE
    kibana-logging   169.169.195.177   <none>         5601/TCP   1h

    # kubectl get rc
    NAME                            DESIRED   CURRENT   AGE
    kibana-logging-v1             1          1          1h

结果表明运行均已成功。通过kubectl cluster-info命令获取Kibana服务的URL地址：

# kubectl cluster-info
Kibana is running at
http://127.0.0.1:8080/api/v1/proxy/namespaces/kube-system/
services/kibana-logging

同样通过kubectl proxy命令启动代理，在出现“Startingto serve on 127.0.0.1:8001”字样之后，用浏览器访问URL地址http://192.168.18.3:8001/api/v1/proxy/namespaces/kube-system/services/kibana-logging即可访问Kibana页面。

第1次进入页面时需要进行一些设置，如图所示，选择所需选项后单击create按钮。
在这里插入图片描述
然后单击discover按钮，就可以正常查询日志了，如图所示。

在搜索栏输入“error”关键字，可以搜索出包含该关键字的日志记录，如图所示。

同时，通过左边菜单中Fields相关的内容对查询的内容进行限定，如图所示。
在这里插入图片描述
至此，Kubernetes集群范围内的统一日志收集和查询系统就搭建完成了。