Jonk的个人学习记录站

Jonk的个人学习记录站

全栈程序员

SpringCloud On Kubernets

原文地址 https://www.baeldung.com/spring-cloud-kubernetes

代码地址:https://github.com/eugenp/tutorials/tree/master/spring-cloud-modules/spring-cloud-kubernetes

一,概述

SpringCloud由于有自己的微服务管理方式,但是当前云原生流行Kubernetes,如果我们决定选择 Kubernetes 作为我们解决方案的主要容器管理器和部署平台,我们仍然可以主要通过 Spring Cloud Kubernetes项目来实现与Kubernetes 的轻松集成。

在本教程中,我们将:

  • 在我们的本地机器上安装 Minikube
  • 开发一个微服务架构示例,其中两个独立的 Spring Boot 应用程序通过 REST 进行通信
  • 使用 Minikube 在单节点集群上设置应用程序
  • 使用YAML配置文件部署应用程序

二、Minikube

安装方式

官方文档https://minikube.sigs.k8s.io/docs/start/

minikube 是本地 Kubernetes,专注于让 Kubernetes 易于学习和开发。只要我们本地环境中安装了Docker,那么只需一条命令即可使用 Kubernetes:

minikube start

MacOS安装方式:

brew install minikube

启动本地单节点 Kubernetes 集群:

minikube start --vm-driver=virtualbox

此命令创建一个使用 VirtualBox 驱动程序运行 Minikube 集群的虚拟机。kubectl中的默认上下文现在将是minikube。但是,为了能够在上下文之间切换,

kubectl config use-context minikube

Kubernetes仪表盘

minikube dashboard

停止集群

minikube stop

创建服务

默认情况下,Pod 只能通过其在 Kubernetes 集群内的内部 IP 地址进行访问。为了使hello-node容器可以从 Kubernetes 虚拟网络外部访问,您必须将 Pod 作为 Kubernetes服务公开。

  1. 使用以下命令将 Pod 公开到公共互联网kubectl expose

    kubectl expose deployment hello-node --type=LoadBalancer --port=8080

    --type=LoadBalancer标志表示您希望在集群外部公开您的服务。

    测试映像内的应用程序代码仅侦听 TCP 端口 8080。如果您曾经 kubectl expose公开不同的端口,则客户端无法连接到该其他端口。

  2. 查看您创建的服务:

    kubectl get services

    输出类似于:

    NAME         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
    hello-node   LoadBalancer   10.108.144.78   <pending>     8080:30369/TCP   21s
    kubernetes   ClusterIP      10.96.0.1       <none>        443/TCP          23m

    在支持负载均衡器的云提供商上,将配置外部 IP 地址来访问服务。在 minikube 上,该LoadBalancer类型使服务可以通过minikube service 命令访问。

  3. 运行以下命令:

    minikube service hello-node

    这将打开一个浏览器窗口,为您的应用程序提供服务并显示应用程序的响应。

    =

三、部署

示例代码: https://github.com/eugenp/tutorials/tree/master/spring-cloud-modules/spring-cloud-kubernetes

首先使用maven clean 和maven package做重新打包,可以使用IDEA的maven插件,先添加kubernets-guide项目,在该项目下做maven命令的运行,

此时运行: sh deployment-travel-client.sh

部署结束后使用会展示部署的pod

% kubectl get pod
NAME                                     READY   STATUS    RESTARTS   AGE
client-service-675b8645dc-b8qxg          1/1     Running   0          89s
travel-agency-service-8546b9968f-27skw   1/1     Running   0          90s
travel-agency-service-8546b9968f-qrgnn   1/1     Running   0          90s

查看部署服务的service

% kubectl get service
NAME                    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)           AGE
client-service          NodePort    10.110.144.4     <none>        8080:30083/TCP    25m
kubernetes              ClusterIP   10.96.0.1        <none>        443/TCP           4h16m
mongodb-service         NodePort    10.97.205.39     <none>        27017:31983/TCP   25m
travel-agency-service   NodePort    10.105.219.194   <none>        8080:30081/TCP    25m

查看client-serivce在minikube上的service信息

 % minikube service client-service 
|-----------|----------------|-------------|---------------------------|
| NAMESPACE |      NAME      | TARGET PORT |            URL            |
|-----------|----------------|-------------|---------------------------|
| default   | client-service |        8080 | http://192.168.49.2:30083 |
|-----------|----------------|-------------|---------------------------|
🏃  Starting tunnel for service client-service.
|-----------|----------------|-------------|------------------------|
| NAMESPACE |      NAME      | TARGET PORT |          URL           |
|-----------|----------------|-------------|------------------------|
| default   | client-service |             | http://127.0.0.1:60732 |
|-----------|----------------|-------------|------------------------|
🎉  正通过默认浏览器打开服务 default/client-service...
❗  因为你正在使用 darwin 上的 Docker 驱动程序,所以需要打开终端才能运行它。

这时候通过访问http://127.0.0.1:60732/就可以访问到client-service


CPU高负载排查

本文将介绍如何排查 Linux 系统中 CPU 负载过高的问题。当系统的 CPU 负载过高时,可能会导致系统响应变慢、进程无响应等问题,影响系统的稳定性和性能。本文将从系统监控、进程分析、资源限制等方面介绍如何定位和解决 CPU 负载过高的问题。通过本文的介绍,读者将了解如何使用常用的工具和技术来排查 CPU 负载过高的问题,提高系统的稳定性和性能。

初级方法

进入系统中查看所有进程占用资源的详细情况,可以使用kubectl exec命令进入pod中的容器,并使用top或ps命令查看进程信息。

以下是具体步骤:

  1. 使用kubectl exec命令进入pod中的容器,例如:

    kubectl exec -it <pod-name> -c <container-name> -- /bin/bash

    这个命令可以进入pod中的指定容器,并打开一个交互式的bash终端。

  2. 在容器中使用top或ps命令查看进程信息,例如:

    top

    或者

    ps aux

    这些命令可以显示容器中所有进程的详细信息,包括进程ID、CPU和内存使用情况、进程状态等。

  3. 如果需要查看某个进程的详细信息,可以使用ps命令结合grep命令来查找进程,例如:

    ps aux | grep <process-name>

    这个命令可以查找容器中指定名称的进程,并显示其详细信息。

通过以上步骤,可以进入pod中查看所有进程占用资源的详细情况,并找出可能的性能瓶颈和优化方案。注意,在进入pod中查看进程信息时,需要确保容器中已经安装了相应的工具和命令,例如top和ps命令。

从监控上看cpu占用很高95%+,但是使用上面的top命令和ps aux都没有找到占用CPU比率超过5%的进程

如果从监控上看到CPU占用很高,但是使用top命令和ps aux命令没有找到占用CPU比率超过5%的进程,可能有以下几种情况:

  1. CPU占用率高的进程已经结束:在top命令和ps aux命令执行期间,可能有一些CPU占用率高的进程已经结束了,导致无法在进程列表中找到。可以使用历史监控数据来查看CPU占用率高的时间段,以找到可能的进程。
  2. CPU占用率高的进程是短暂的:有些进程可能只是短暂地占用了CPU资源,例如一些周期性的任务或者瞬时的请求处理。这些进程可能无法在top命令和ps aux命令中被捕捉到。可以使用更高级的监控工具来捕捉这些短暂的进程,例如perf和strace。
  3. CPU占用率高的进程是内核进程:有些CPU占用率高的进程可能是内核进程,例如中断处理、IO操作等。这些进程可能无法在用户空间的进程列表中被捕捉到。可以使用更高级的监控工具来查看内核进程的CPU占用率,例如sar和vmstat。
  4. CPU占用率高的进程是被隐藏的:有些恶意软件或者攻击可能会隐藏自己的进程,以避免被发现。这些进程可能无法在top命令和ps aux命令中被捕捉到。可以使用更高级的安全工具来检测和清除这些恶意进程,例如rkhunter和chkrootkit。

可以使用以下工具进一步跟踪:

  1. perf命令:perf是一个Linux性能分析工具,可以用来分析CPU、内存、磁盘和网络等方面的性能问题。可以使用以下命令来查看CPU占用率高的进程:

    perf top

    这个命令可以显示CPU占用率高的进程和函数,以及相应的CPU时间和调用次数等信息。

  2. strace命令:strace是一个Linux系统调用跟踪工具,可以用来跟踪进程的系统调用和信号处理等操作。可以使用以下命令来跟踪CPU占用率高的进程:

    strace -p <pid>

    这个命令可以显示进程的系统调用和信号处理等操作,以帮助你找出可能的性能瓶颈和优化方案。

  3. sar命令:sar是一个Linux系统性能监控工具,可以用来收集和分析系统的CPU、内存、磁盘和网络等性能数据。可以使用以下命令来查看CPU占用率高的时间段:

    sar -u <start-time> <end-time>

    这个命令可以显示系统的CPU使用率和负载情况,以帮助你找出可能的性能瓶颈和优化方案。

  4. vmstat命令:vmstat是一个Linux虚拟内存统计工具,可以用来收集和分析系统的CPU、内存、磁盘和网络等性能数据。可以使用以下命令来查看CPU占用率高的时间段:

    vmstat <interval> <count>

    这个命令可以显示系统的CPU使用率、内存使用率和磁盘IO情况等,以帮助你找出可能的性能瓶颈和优化方案。

  5. htop命令:htop是一个交互式的进程监控工具,可以用来查看进程的CPU、内存和IO等使用情况。可以使用以下命令来查看CPU占用率高的进程:

    htop

    这个命令可以显示进程的CPU使用率、内存使用率和IO情况等,以帮助你找出可能的性能瓶颈和优化方案。

htop 命令中,time+ 列显示的是进程的累计 CPU 时间,包括用户态和内核态的 CPU 时间。当进程的累计 CPU 时间超过1小时时,htop 会将时间格式化为 1h08:30 的形式,其中 1h 表示1小时,08:30 表示剩余的分钟和秒数。

例如,如果一个进程的 time+ 列显示为 1h08:30,表示该进程的累计 CPU 时间为1小时8分30秒。如果一个进程的 time+ 列显示为 00:01:30,表示该进程的累计 CPU 时间为1分30秒。

需要注意的是,htop 中的 time+ 列显示的是累计 CPU 时间,并不是实际的运行时间。如果一个进程在某个时间段内没有占用 CPU,那么它的 time+ 列也不会增加。因此,time+ 列并不能完全反映进程的运行时间,只能作为一个参考指标。

磁盘和内存占用情况

在 Linux 系统中,可以使用以下命令来查看文件的磁盘占用情况:

  1. ls 命令:该命令可以列出文件的详细信息,包括文件大小和修改时间等。例如,使用以下命令可以列出当前目录下所有文件的详细信息:

    ls -l

    在输出结果中,第5列为文件大小,以字节为单位。

  2. du 命令:该命令可以查看文件或目录的磁盘占用情况。例如,使用以下命令可以查看当前目录下所有文件的磁盘占用情况:

    du -h

    在输出结果中,第1列为文件或目录的磁盘占用大小,以人类可读的格式显示(例如,KB、MB、GB 等)。

  3. df 命令:该命令可以查看文件系统的磁盘占用情况。例如,使用以下命令可以查看当前系统中所有文件系统的磁盘占用情况:

    df -h

    在输出结果中,第3列为文件系统的总容量,第4列为已使用的容量,第5列为可用的容量,第6列为使用率。

需要注意的是,以上命令都可以通过参数来指定要查看的文件或目录。例如,使用 ls -l /path/to/file 命令可以查看指定文件的详细信息,使用 du -h /path/to/directory 命令可以查看指定目录的磁盘占用情况。

你可以使用 du 命令来按目录维度展示内存占用情况。du 命令可以查看文件或目录的磁盘占用情况,并支持按照目录层级展示结果。

以下是按目录维度展示内存占用的示例命令:

du -h --max-depth=1 /path/to/directory

在上面的命令中,-h 选项表示以人类可读的格式显示结果,--max-depth=1 选项表示只展示一级目录的结果,/path/to/directory 是要查看的目录路径。

如果要展示多级目录的结果,可以将 --max-depth 选项的值设置为相应的层级数。例如,要展示两级目录的结果,可以使用以下命令:

du -h --max-depth=2 /path/to/directory

需要注意的是,du 命令默认会递归地查看目录下所有子目录的磁盘占用情况,因此在查看大型目录时可能需要等待一段时间。如果只想查看目录本身的磁盘占用情况,可以使用 -s 选项。例如,使用以下命令可以查看 /path/to/directory 目录本身的磁盘占用情况:

du -h -s /path/to/directory

/sys/fs/cgroup 目录是 Linux 内核中的一个虚拟文件系统,用于管理 cgroup。cgroup 是一种 Linux 内核特性,用于限制和隔离进程的资源使用,包括 CPU、内存、磁盘等资源。

/sys/fs/cgroup 目录下,每个子目录都代表一个 cgroup,其中包含了该 cgroup 的资源限制和统计信息。例如,/sys/fs/cgroup/memory 目录下包含了内存限制和统计信息,/sys/fs/cgroup/cpu 目录下包含了 CPU 限制和统计信息,/sys/fs/cgroup/blkio 目录下包含了磁盘 I/O 限制和统计信息等。

因此,/sys/fs/cgroup 目录中的信息反映的是 cgroup 中的资源使用情况,包括内存、CPU、磁盘等资源。在上面的代码中,/sys/fs/cgroup/memory 目录用于获取容器的内存使用情况,包括内存限制、内存使用量和内存统计信息。

/sys/fs/cgroup 目录下的内存信息只能代表当前 cgroup 的内存使用情况,不能代表整个 pod 的内存使用量。一个 pod 可能包含多个容器,每个容器都有自己的 cgroup,因此需要分别获取每个容器的内存使用情况,才能得到整个 pod 的内存使用量。

在 Kubernetes 中,可以通过 kubectl top pod 命令来获取 pod 的 CPU 和内存使用情况。该命令会返回每个容器的 CPU 和内存使用量,以及整个 pod 的 CPU 和内存使用量。该命令的实现原理是通过调用 Kubernetes API 获取容器的 CPU 和内存使用情况,然后将其汇总计算得到整个 pod 的 CPU 和内存使用量。

因此,如果需要获取整个 pod 的内存使用量,建议使用 kubectl top pod 命令或者调用 Kubernetes API 来获取容器的内存使用情况,并将其汇总计算得到整个 pod 的内存使用量。

如果您从当前 pod 的控制台进入 /sys/fs/cgroup 目录,那么您所看到的 /sys/fs/cgroup/memory 目录下的内存信息将代表当前 pod 的内存使用量。这是因为在 pod 内部,每个容器都会有自己的 cgroup,并且 pod 的 cgroup 会包含所有容器的 cgroup。

因此,当您在当前 pod 的控制台中查看 /sys/fs/cgroup/memory 目录下的内存信息时,您将看到当前 pod 中所有容器的内存使用情况的汇总。这包括每个容器的内存限制、内存使用量和内存统计信息。

请注意,这仅适用于当前 pod 内部的视角。如果您想获取整个 pod 的内存使用量,您需要在 pod 所在的宿主机上查看相应的资源使用情况,或者使用 Kubernetes API 或相关工具来获取整个 pod 的内存使用量。

cgroup 是 Linux 内核中的一种特性,用于限制和隔离进程的资源使用,包括 CPU、内存、磁盘等资源。cgroup 可以将一组进程组织成一个 cgroup,然后对该 cgroup 中的进程进行资源限制和统计。

在 Linux 中,cgroup 通过虚拟文件系统来实现。cgroup 的虚拟文件系统通常被挂载在 /sys/fs/cgroup 目录下。该目录下的子目录代表不同的 cgroup 类型,例如 cpumemoryblkio 等。每个 cgroup 类型下又包含了多个 cgroup,每个 cgroup 代表一个 cgroup 实例。

/sys/fs/cgroup 目录下,每个 cgroup 实例都有自己的一组虚拟文件,用于限制和统计该 cgroup 中进程的资源使用情况。例如,在 memory cgroup 中,可以通过 memory.limit_in_bytes 文件来限制 cgroup 中进程的内存使用量,通过 memory.usage_in_bytes 文件来统计 cgroup 中进程的内存使用量。

/sys/fs 目录是 Linux 中的一个虚拟文件系统,用于提供文件系统相关的信息和接口。/sys/fs/cgroup 目录下的虚拟文件系统是 sysfs 文件系统的一个子目录,用于提供 cgroup 相关的信息和接口。因此,fs/sys/fs/cgroup 中代表 sysfs 文件系统。

在 Linux cgroup 中,当进程的内存使用率高时,所指的内存通常是虚拟内存,而不一定是系统实际的物理内存。

虚拟内存是一种抽象概念,它将进程的地址空间划分为多个虚拟页面,每个页面可以映射到物理内存、磁盘交换空间或其他设备。进程使用的内存可以超过系统实际可用的物理内存大小,因为虚拟内存允许将未使用的页面交换到磁盘上,以释放物理内存供其他进程使用。

在 cgroup 中,内存使用率通常是基于虚拟内存的统计。例如,memory.usage_in_bytes 文件中记录的是进程使用的虚拟内存大小,而不是实际占用的物理内存大小。因此,当 cgroup 中进程的内存使用率高时,表示进程正在使用较多的虚拟内存资源。

要了解系统实际的物理内存使用情况,需要综合考虑所有进程的虚拟内存使用情况、系统缓存、内核使用的内存等因素。可以使用工具如 freetophtop 等来查看系统的物理内存使用情况。

分析实例

htop工具分析出以下数据

op - 10:12:52 up 3 days,  5:29,  0 users,  load average: 12.97, 13.51, 13.64
Tasks:   8 total,   1 running,   7 sleeping,   0 stopped,   0 zombie
%Cpu0  :  39.9/60.1  100[|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||]     %Cpu1  :  37.7/62.3  100[|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||]
GiB Mem : 34.8/3.8      [                                                                 ]
GiB Swap:  0.0/0.0      [                                                                 ]

    PID USER      PR  NI    VIRT    RES  %CPU  %MEM     TIME+ S COMMAND                                                                                                                      
      1 root      20   0    0.8m   0.0m   0.0   0.0   0:03.46 S tini -- docker-entrypoint.sh                                                                                                 
      7 root      20   0    2.3m   1.7m   0.0   0.0   0:00.00 S  `- /bin/bash /bin/docker-entrypoint.sh                                                                                      
     83 root      20   0    1.6m   0.0m   0.0   0.0   0:03.60 S      `- tail -f /dev/null                                                                                                    
     82 root      20   0    1.6m   0.7m   0.0   0.0   0:01.28 S  `- crond                                                                                                                    
  99542 root      20   0  700.1m  16.3m   0.0   0.4   0:04.83 S  `- ./bin/zhiyan-log-docker-conf -config-file config/system/confd.toml                                                       
  99558 root      20   0  756.9m  72.8m   0.0   1.9   0:06.59 S  `- ./bin/zhiyan-log-docker-agent -c ./config/user/filebeat.yaml                                                             
 134993 root      20   0    2.5m   2.2m   0.0   0.1   0:00.00 S /bin/bash

​ 从top命令输出来看,CPU占用率非常高,,负载均衡也很高,也就是load average的值非常高,分别为12.97、13.51和13.64。load average是系统负载的一个指标,它表示在过去1分钟、5分钟和15分钟内,系统中平均有多少个进程处于就绪状态或者等待资源状态。一般来说,load average的值越高,表示系统的负载越大,CPU利用率也越高但是没有一个进程占用了大量的CPU资源。这种情况可能是由于多个进程共同占用了CPU资源,导致CPU占用率高但是没有一个进程占用大量CPU资源。

​ 正常的load average的值的区间取决于系统的硬件配置、负载情况和应用程序的特性等因素。一般来说,如果系统的load average值在CPU核心数的1-2倍之间,表示系统的负载比较正常。例如,如果系统有4个CPU核心,那么load average值在4-8之间是比较正常的。如果load average值超过了CPU核心数的2倍,表示系统的负载比较高,需要进一步分析和优化。

​ 另外,从%Cpu(s)的输出来看,CPU利用率也非常高,us和sy的值分别为38.1%和61.5%,表示CPU的大部分时间都在处理用户进程和系统进程。这也说明了为什么load average的值非常高。

详细分析进程

​ 在Linux系统中是如何区分区分系统进程和用户进程的呢?每个进程都有一个UID,用来标识进程所属的用户。系统进程通常是由root用户或其他系统用户启动的,它们的UID为0或其他系统用户的UID。这些进程通常是用来管理系统资源、执行系统任务、提供系统服务等,例如init进程、systemd进程、sshd进程等。用户进程通常是由普通用户启动的,它们的UID为普通用户的UID。这些进程通常是用来执行用户任务、运行应用程序等,例如浏览器进程、编辑器进程、编译器进程等。

可以使用ps命令或top命令来查看进程的UID和其他信息,例如:

ps aux | grep <进程名>

其中,<进程名>是要查找的进程名。执行该命令后,会输出进程的UID、PID、CPU占用率、内存占用率等信息。通过查看进程的UID,可以区分系统进程和用户进程。

我们看到python进程占有CPU相对高,那么进一步排查它,我们先在inux查看python进程占用端口的进程活跃情况,是否有请求进来

使用netstat命令来查看某个端口的进程活跃情况和是否有请求进来。下面是netstat命令的使用方法:

  1. 查看某个端口的进程活跃情况:

    netstat -tlnp | grep <port>

    其中,是要查看的端口号。执行该命令后,会输出所有监听该端口的进程信息,包括进程的PID、进程名、协议等。

  2. 查看某个端口的请求情况:

    netstat -anp | grep <port>

    其中,是要查看的端口号。执行该命令后,会输出所有与该端口建立的连接信息,包括本地IP地址、本地端口号、远程IP地址、远程端口号、连接状态等。

由于端口8000正在被Python进程占用,并且该进程正在监听该端口。这意味着该端口已经被占用,但是当前并没有任何连接建立。

如果你想查看该端口是否有请求进来,可以使用类似以下命令:

复制tcpdump -i any port 8000

该命令会在终端中输出所有与端口8000建立的连接信息,包括本地IP地址、本地端口号、远程IP地址、远程端口号、连接状态等。需要注意的是,tcpdump命令需要root权限才能执行。

[root@postpay-lifecyclemgr-intl-2255-0 /]# tcpdump -i any port 8000
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on any, link-type LINUX_SLL (Linux cooked), capture size 262144 bytes
19:58:01.665950 IP localhost.59584 > localhost.irdmi: Flags [S], seq 985772684, win 65535, options [mss 65495,sackOK,TS val 3005806978 ecr 0,nop,wscale 9], length 0
19:58:01.665969 IP localhost.irdmi > localhost.59584: Flags [S.], seq 2185908257, ack 985772685, win 65535, options [mss 65495,sackOK,TS val 3005806978 ecr 3005806978,nop,wscale 9], length 0
19:58:01.665985 IP localhost.59584 > localhost.irdmi: Flags [.], ack 1, win 128, options [nop,nop,TS val 3005806978 ecr 3005806978], length 0
19:58:01.666064 IP localhost.59584 > localhost.irdmi: Flags [P.], seq 1:83, ack 1, win 128, options [nop,nop,TS val 3005806978 ecr 3005806978], length 82
19:58:01.666072 IP localhost.irdmi > localhost.59584: Flags [.], ack 83, win 128, options [nop,nop,TS val 3005806978 ecr 3005806978], length 0
19:58:01.667408 IP localhost.irdmi > localhost.59584: Flags [P.], seq 1:175, ack 83, win 128, options [nop,nop,TS val 3005806980 ecr 3005806978], length 174
19:58:01.667418 IP localhost.59584 > localhost.irdmi: Flags [.], ack 175, win 131, options [nop,nop,TS val 3005806980 ecr 3005806980], length 0

据tcpdump命令输出来看,该端口正在接收来自本地IP地址为localhost、本地端口号为59584的TCP连接请求。该连接请求的目的地是本地IP地址为localhost、目标端口号为irdmi的TCP端口。同时,该连接请求的标志位为S,表示该连接请求是一个同步请求。

如果你想查看更多关于该连接请求的信息,可以使用类似以下命令:

tcpdump -i any port 8000 -nnvvS

该命令会在终端中输出更详细的关于连接请求的信息,包括源IP地址、源端口号、目的IP地址、目的端口号、标志位等。需要注意的是,该命令的输出比较详细,可能会比较难以理解。

tcpdump命令输出的结果可以看到端口的请求并不活跃,由此可得出CPU高的原因可能不是它

分析定时任务

在Linux系统中,可以使用crontab命令来管理定时任务。下面是一些常用的crontab命令:

  1. 查看当前用户的定时任务:

    crontab -l

    该命令会列出当前用户的所有定时任务。

  2. 编辑当前用户的定时任务:

    crontab -e

    该命令会打开当前用户的定时任务配置文件,你可以在该文件中添加、修改或删除定时任务。

  3. 删除当前用户的所有定时任务:

    crontab -r

    该命令会删除当前用户的所有定时任务。

需要注意的是,crontab命令只能管理当前用户的定时任务,如果你想查看其他用户的定时任务,需要使用root权限执行crontab命令。另外,定时任务的配置文件通常位于/var/spool/cron目录下,你可以使用类似以下命令来查看该目录下的所有定时任务文件:

ls -l /var/spool/cron

据定时任务配置,以下是每个任务的周期和频率:

  1. /1 * * * * 表示每分钟执行一次,即每分钟的第0秒执行 /usr/local/bin/cpu_usage_updater.py &>/dev/null 命令。
  2. /1 * * * * 表示每分钟执行一次,即每分钟的第0秒执行 chmod a+w /dev/shm/.pkgadmin.cron.lck 命令。
  3. */2 * * * * 表示每2分钟执行一次,即每2分钟的第0秒执行 bash /data/release/bill-assistant/console_health_check.sh 命令。
  4. * * * * * 表示每分钟执行一次,即每分钟的第0秒执行 chown -R user_00:users /data/release/postpay-lifecyclemgr-intl/chown -R user_00:users /data/log/postpay-lifecyclemgr-intl/ 命令。
  5. 0 0 * * * 表示每天的0点0分执行一次,即每天的0点0分执行 cat /dev/null > /data/log/php-7_2_1-swoole_4_5_1_qbilling-1.0/php_errors.log 命令。

需要注意的是,定时任务的周期和频率可以通过修改crontab配置文件来调整。如果你想修改定时任务的周期和频率,可以使用 crontab -e 命令编辑crontab配置文件,并按照crontab语法修改相应的定时任务配置。

要修改crontab并使其生效,你需要执行以下步骤:

  1. 使用 crontab -e 命令编辑当前用户的定时任务配置文件。
  2. 修改定时任务的周期和命令,并保存文件。
  3. 确认定时任务配置文件已经保存,并退出编辑器。
  4. 重启cron服务,使新的定时任务配置生效。你可以使用以下命令重启cron服务:

    sudo systemctl restart cron

    如果你的系统不是基于systemd的,可以使用以下命令重启cron服务:

    sudo service cron restart

    重启cron服务后,新的定时任务配置就会生效。

需要注意的是,修改定时任务配置文件后,新的定时任务不会立即生效,而是要等待cron服务下一次执行定时任务时才会生效。如果你想立即执行新的定时任务,可以手动执行一次定时任务,或者重启cron服务。另外,如果你修改了root用户的定时任务配置文件,需要使用root权限执行以上操作。

查看日志技巧

在Linux系统中,可以使用以下命令来查看日志文件:

  1. tail 命令:该命令可以实时查看日志文件的最新内容。例如,使用以下命令可以查看 /var/log/messages 文件的最后10行内容:

    复制tail /var/log/messages

    如果想实时查看日志文件的最新内容,可以使用 -f 选项。例如,使用以下命令可以实时查看 /var/log/messages 文件的最新内容:

    复制tail -f /var/log/messages
  2. less 命令:该命令可以分页查看日志文件的内容,并支持搜索。例如,使用以下命令可以查看 /var/log/messages 文件的内容:

    复制less /var/log/messages

    less 命令中,可以使用 / 命令来搜索关键字。例如,输入 /error 可以搜索包含 error 关键字的内容。

  3. grep 命令:该命令可以搜索指定文件中包含指定关键字的行。例如,使用以下命令可以搜索 /var/log/messages 文件中包含 error 关键字的行:

    复制grep "error" /var/log/messages

    如果想搜索多个文件,可以使用通配符 *。例如,使用以下命令可以搜索 /var/log 目录下所有以 messages 开头的文件中包含 error 关键字的行:

    复制grep "error" /var/log/messages*

需要注意的是,日志文件通常存储在 /var/log 目录下,不同的日志文件对应不同的应用程序或系统组件。在查看日志文件时,需要根据实际情况选择相应的日志文件,并使用合适的命令进行查看和搜索。


Helm基础知识

  • Helm 的概述和功能

    • Helm 是一个 Kubernetes 应用程序包管理器,它提供了一种简单、可重复、可扩展的方式来安装、升级和管理 Kubernetes 应用程序
    • Helm是k8s包管理工具,用来简化应用的部署和管理。我们知道在k8s中各种资源是用yaml来描述,而helm可以把yaml模板化,让运营人员根据需要配置并实例化应用。

      假设一应用有dev、test、qa、live环境,每个环境实例数,配置文件,namespace等等都不同,如没有helm,则需要4套yaml资源包,带来极大维护成本。而通过helm则可把可变部分参数化,集中放入value.yaml文件

  • Helm 的术语和组件(例如,Chart、Release、Repository 等)
  1. Chart Chart 是 Helm 中的核心概念之一,它表示一个预先定义好的 Kubernetes 应用程序的包。Chart 包含应用程序的定义、依赖项、默认配置等信息。一个 Chart 可以包含多个 Kubernetes 资源对象,例如 Deployment、Service、ConfigMap 等。
  2. Release Release 表示通过 Chart 安装的运行中的应用程序实例。当用户使用 Chart 安装应用程序时,Helm 会生成一个 Release 实例。Release 包含应用程序的状态信息、配置选项等内容。一个 Chart 可以生成多个 Release 实例,每个实例都可以具有不同的配置和状态。
  3. Repository Repository 是 Helm Chart 存储和分享的位置。Chart 开发人员可以将 Chart 打包为 tar 包并上传到 Repository 中,其他用户可以从 Repository 中获取 Chart 并使用 Helm 安装它们。Helm 默认包含一个官方 Chart 仓库,开发人员也可以创建自己的私有 Chart 仓库。

             +-----------------------+
             |                       |
             |       Repository      |
             |                       |
             +-----------+-----------+
                         |
                Chart    |   Release
                         |
             +-----------v-----------+
             |                       |
             |        Helm           |
             |                       |
             +-----------------------+
    
  • Helm 的架构和工作原理

    • 架构: Helm 的架构分为两个部分:Helm 客户端和 Tiller 服务端。Helm 客户端是一个命令行工具,它允许用户从 Chart 仓库中查找、安装、升级和删除应用程序。Tiller 是一个 Kubernetes 组件,它在集群中运行,并处理 Helm 客户端发送的请求。Tiller 从 Chart 中生成 Kubernetes 资源对象,并将它们部署到 Kubernetes 集群中。
    • 工作流程:

      • 创建 Chart Chart 开发人员创建 Chart,包括 Chart.yaml、templates/ 目录下的 Kubernetes 资源模板文件以及任何相关文件。
      • 打包 Chart 开发人员使用 helm package 命令将 Chart 打包为 tar 包,并将其上传到 Chart 仓库。
      • 安装 Chart 用户使用 helm install 命令安装 Chart,并指定 Chart 的名称和任何所需的值。Helm 客户端从 Chart 仓库中下载 Chart 并将其发送到 Tiller。
      • Tiller 生成 Kubernetes 资源 Tiller 从 Chart 中生成 Kubernetes 资源对象,包括 Deployment、Service、ConfigMap 等,并将它们部署到 Kubernetes 集群中。
      • Release 管理 每个 Release 都有一个唯一的名称,并包含应用程序的状态信息、配置选项等内容。用户可以使用 helm list 命令查看 Release 列表,并使用 helm status、helm upgrade、helm rollback 等命令管理 Release。

    举个例子: 假设有一个名为 myapp 的 Chart,其中包含了一个 Deployment 和一个 Service。开发人员将该 Chart 打包为 tar 包并上传到 Chart 仓库。

    1.首先,进入 Chart 的根目录:

    cd myapp

    然后,运行 helm package 命令来将 Chart 打包为 tar 包。该命令会生成一个名为 myapp-1.0.0.tgz 的文件,其中 1.0.0 是 Chart 的版本号:

    helm package .

    2.用户可以使用以下命令安装 myapp Chart:

    helm install myapp mychartrepo/myapp

    3.接下来,将生成的 tar 包上传到 Chart 仓库。假设我们使用的是 ChartMuseum 作为 Chart 仓库,可以使用以下命令将 tar 包上传到 ChartMuseum:

    $ curl --data-binary "@myapp-1.0.0.tgz" http://chartmuseum.example.com/api/charts

    4.其中,chartmuseum.example.com 是 ChartMuseum 的地址,/api/charts 是 ChartMuseum 提供的上传 API 的路径。可以将该命令添加到 CI/CD 流程中,以便自动构建和上传 Chart。

    上传完成后,其他开发人员和运维人员可以使用 helm install 命令来安装该 Chart。例如:

    helm install myapp chartmuseum.example.com/myapp --version 1.0.0

    Helm 客户端会从 mychartrepo/myapp 仓库中下载 myapp Chart,并将它发送到 Tiller。Tiller 会从 Chart 中生成 Deployment 和 Service 资源对象,并将它们部署到 Kubernetes 集群中。用户可以使用 helm list 命令查看所有 Release 列表,并使用 helm status、helm upgrade、helm rollback 等命令管理 Release。例如,可以使用以下命令升级 myapp Release:

    $ helm upgrade myapp mychartrepo/myapp --set replicaCount=3

    这将更新 myapp Release 的配置选项,并将 Deployment 的副本数设置为 3。

    但是由于私有化的 Kubernetes 环境中不能使用外部的私有化 Chart 仓库,所以TMF通常使用 Helm 命令行工具直接从本地的 Chart 代码库中安装 Chart,Kubernetes 自带了一个 Helm Chart 仓库管理器——Helm chartmuseum,可以使用该管理器将 Chart 打包为 tar 包并上传到 Kubernetes 集群中。在集群中使用 Helm 命令行工具从该 Helm chartmuseum 中安装 Chart。 title=

  • 如何安装和配置 Helm

    • 初始化 Helm:在终端中运行以下命令初始化 Helm:

​ 该命令会在 Kubernetes 集群中安装 Tiller(Helm 2.x 版本),或者在客户端本地生成 ~/.kube/config 文件和 Tiller 实例(Helm 3.x 版本)。

​ 配置权限和 RBAC:在 Kubernetes 中需要配置 RBAC 角色和权限,以便 Helm 客户端可以访问 Kubernetes API Server。可以通过创建一个 service account 并为其配置一个 ClusterRoleBinding 或 RoleBinding,来授予 Helm 客户端所需的权限。例如,以下是创建一个 service account 和 ClusterRoleBinding 的示例:

kubectl create serviceaccount --namespace kube-system tiller

kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller

 title=

Chart 开发和管理

Chart 的结构和文件

一个 Chart 通常包含了一组描述 Kubernetes 资源的 YAML 文件和一个名为 Chart.yaml 的描述 Chart 信息的 YAML 文件,以及一个或多个模板文件,可以使用模板文件动态生成 Kubernetes 资源文件。

一个典型的 Chart 目录结构如下:

my-chart/
  Chart.yaml          # 包含了 Chart 的基本信息,如名称、版本等
  README.md           # Chart 的说明文档
  values.yaml         # 用于配置 Chart 的默认值
  values.schema.json  # 用于验证 values.yaml 的格式
  templates/          # 包含了模板文件和 Kubernetes 资源文件
  charts/             # 包含了 Chart 的依赖 Chart

下面是一个包含了多个云原生应用和依赖关系的 Chart 示例:

my-app-chart/
  Chart.yaml
  README.md
  values.yaml
  templates/
    deployment.yaml
    service.yaml
    ingress.yaml
    configMap.yaml
    secrets.yaml
    _helpers.tpl
    my-app-1/
      Chart.yaml
      README.md
      values.yaml
      templates/
        deployment.yaml
        service.yaml
        configMap.yaml
        _helpers.tpl
    my-app-2/
      Chart.yaml
      README.md
      values.yaml
      templates/
        deployment.yaml
        service.yaml
        configMap.yaml
        _helpers.tpl
  charts/
    my-app-1/
      Chart.yaml
      README.md
      values.yaml
      templates/
        deployment.yaml
        service.yaml
        configMap.yaml
        _helpers.tpl
    my-app-2/
      Chart.yaml
      README.md
      values.yaml
      templates/
        deployment.yaml
        service.yaml
        configMap.yaml
        _helpers.tpl
    my-dependency/
      Chart.yaml
      README.md
      values.yaml
      templates/
        deployment.yaml
        service.yaml
        configMap.yaml
        _helpers.tpl
  • Chart 的模板和值
  • Chart 的版本管理
  • Chart 的打包和发布
  • Chart 的存储库管理

Release 管理和操作

  • Release 的状态和管理
  • Release 的回滚和升级
  • Release 的配置管理
  • Release 的监控和日志

Helm 与 Kubernetes 的集成

Kubernetes 和 Helm 的关系

                                  +------------------+
                                  |                  |
                                  |   Kubernetes     |
                                  |                  |
                                  +------------------+
                                           ^
                                           |
                                           |
                                           |
                                +-----------------------+
                                |                       |
                          +------------+       +------------+
                          |  Helm CLI  |       |  Tiller    |
                          +------------+       +------------+
                                |                       |
                                +-----------------------+
                                           ^
                                           |
                                           |
                                           |
                                           |
                                  +------------------+
                                  |                  |
                                  |   Chart Repo     |
                                  |                  |
                                  +------------------+

Kubernetes 是一个开源的容器编排平台,用于自动化部署、扩展和管理容器化应用程序。它提供了一组 API 和工具,用于管理容器、存储、网络和部署。

Helm 是一个 Kubernetes 应用程序包管理器,用于简化 Kubernetes 应用程序的部署和管理。它使用 Charts 来描述 Kubernetes 资源文件的集合,并使用 Tiller 来将 Charts 安装到 Kubernetes 集群中。Helm CLI 是 Helm 的命令行接口,用于创建、打包、安装、升级和删除 Charts。Chart Repo 是一个用于存储和共享 Charts 的仓库。

Tiller 是 Helm 的服务端组件,用于在 Kubernetes 集群中管理 Charts。它负责将 Charts 转换为 Kubernetes 资源文件,并将它们安装到 Kubernetes 集群中。Tiller 运行在 Kubernetes 集群中,可以访问 Kubernetes API Server,并使用 Kubernetes RBAC(Role-Based Access Control)来限制用户对 Kubernetes 资源的访问权限。

  • Helm 与 Kubernetes 的资源类型和 API 对象
  • Kubernetes 对 Helm 的支持和限制
  • Helm 的插件和扩展

Helm 的最佳实践

以一个包含多个云原生应用的电子商务应用为例,来演示如何使用 Helm 对其进行管理。

  1. 创建 Helm Chart 文件

我们可以使用 Helm CLI 的 create 命令创建一个基本的 Helm Chart,例如:

$ helm create ecommerce-app

这将创建一个名为 ecommerce-app 的目录,并在其中生成一些默认的文件,例如 values.yamlChart.yamltemplates 目录等。然后,我们可以根据需要修改这些文件以适应电子商务应用的需求,例如:

  • values.yaml 中定义应用程序所需的值,例如数据库用户名、密码等;
  • Chart.yaml 中定义应用程序的名称、版本等信息;
  • templates 目录中定义 Kubernetes 资源,例如 Deployment、Service、ConfigMap 等。
  1. 打包 Helm Chart

一旦我们创建了 Helm Chart 文件,就可以使用 Helm CLI 的 package 命令将其打包为一个 tar 包,例如:

  1. 打包 Helm Chart

一旦我们创建了 Helm Chart 文件,就可以使用 Helm CLI 的 package 命令将其打包为一个 tar 包,例如:

goCopy code
$ helm package ecommerce-app

这将在当前目录中生成一个名为 ecommerce-app-0.1.0.tgz 的 tar 包,其中 0.1.0 是 Chart 的版本号。

  1. 部署 Helm Chart

在部署 Helm Chart 之前,我们需要将其上传到一个私有化的 Chart 仓库中。假设我们已经在 Kubernetes 集群中部署了一个私有化的 Chart 仓库,其 URL 为 http://my-chart-repo,我们可以使用 Helm CLI 的 push 命令将 Helm Chart 上传到该仓库中,例如:

perlCopy code
$ helm push ecommerce-app-0.1.0.tgz my-chart-repo

这将把 ecommerce-app-0.1.0.tgz 上传到名为 my-chart-repo 的 Chart 仓库中。

一旦 Helm Chart 已经上传到 Chart 仓库中,我们可以使用 Helm CLI 的 install 命令将其安装到 Kubernetes 集群中,例如:

cssCopy code
$ helm install --name ecommerce-app --namespace ecommerce --set database.username=admin, database.password=secret my-chart-repo/ecommerce-app

这将在名为 ecommerce 的命名空间中安装名为 ecommerce-app 的 Helm Release,其中 --set 参数用于设置应用程序的参数,例如数据库用户名和密码。

  1. 检查 Helm Release

一旦 Helm Release 安装成功,我们可以使用 Helm CLI 的 list 命令来查看已安装的 Helm Release,例如:

rubyCopy code
$ helm list

这将列出所有已安装的 Helm Release。我们也可以使用 status 命令来检查 Helm Release 的状态,例如:

luaCopy code
$ helm status ecommerce-app

这将输出名为 ecommerce-app 的 Helm Release 的详细信息。

总的来说,使用 Helm 对包含多个云原生应用的电子商务应用进行管理,可以提高应用程序的部


常用Linux命令

查看进程

# 检查参数
# agent yunti env
# agent config topic of yun ti env 
# support env of sam qa kafka
ps -ef | grep nginx

netstat -ntpl

上传下载文件

#下载
wget -c http://client.hub.confluent.io/confluent-hub-client-latest.tar.gz

# 下载文件
scp username@servername:/path/filename /tmp/local_destination

# 上传本地文件到服务器
scp /path/local_filename username@servername:/path  

# 下载文件目录
scp -r username@servername:remote_dir/ /tmp/local_dir 

# 上传文件目录
scp  -r /tmp/local_dir username@servername:remote_dir

文件编辑

编译打包:

./mvnw compile -Dmaven.test.skip=true

./mvnw clean package -Dmaven.test.skip

./mvnw clean package -Dmaven.test.skip -Dcheckstyle.skip


#上传:
rz -ybe


#从服务端发送文件到客户端:
sz filename

#从客户端上传文件到服务端:
rz

# 解压:
tar -zxvf

# 显示文件大小
ls -lh

定时任务

# 编辑添加定时任务:
crontab -e

# 开启定时任务
service crond start


# [Linux根据端口号关闭相应的进程Shell脚本](https://www.google.com.hk/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwizu-fPspH7AhUBgVYBHY36AlMQFnoECBgQAQ&url=https%3A%2F%2Fcodeantenna.com%2Fa%2FuKHwIdFM3t&usg=AOvVaw0GMneiGw-ewNKVlBGmhPSt)
kill -9 $(lsof -i:12800 |awk '{print $2}' | tail -n 2)

# Linux定时任务
# 每晚的21:30重启smb

```
30 21 * * * /etc/init.d/smb restart
```

vim  ~/.bash_profile

Git删除子模块
有时子模块的项目维护地址发生了变化,或者需要替换子模块,就需要删除原有的子模块。

删除子模块较复杂,步骤如下:

rm -rf 子模块目录 删除子模块目录及源码
vi .gitmodules 删除项目目录下.gitmodules文件中子模块相关条目
vi .git/config 删除配置项中子模块相关条目
rm .git/module/* 删除模块下的子模块目录,每个子模块对应一个目录,注意只删除对应的子模块目录即可
执行完成后,再执行添加子模块命令即可,如果仍然报错,执行如下:

git rm --cached 子模块名称

完成删除后,提交到仓库即可。