Kubernetes 几种存储方式性能对比 （转载）

Posted 2023-04-06

参考技术A 原文来自：

https://blog.fleeto.us/post/kubernetes-storage-performance-comparison/

摘要

本文展示了一个简单的存储对比，使用未经性能优化的多种存储提供的存储卷进行测试和比较。

忽略 Azure 的原生 PVC 或hostPath，我们可以得出如下测试结果：

1. Portworx 是 AKS 上最快的容器存储。

2. Ceph 是私有云集群上最快的开源存储后端。对公有云来说，其操作太过复杂，这些多余的复杂性并没有能提供更好的测试表现。

3. OpenEBS 的概念很棒，但是其后端需要更多优化。

如果你正在运行 Kubernetes，你可能正在使用，或者准备使用动态供给的块存卷 ，而首当其冲的问题就是为集群选择合适的存储技术。这个事情并不能用一个简单的测试来做出简单的回答，告诉你目前市面上最好的技术是什么。存储技术的选择过程中，集群上运行的负载类型是一个重要的输入。对于裸金属集群来说，需要根据实际用例进行选择，并集成到自己的硬件之中。公有云中的托管 K8s，例如 AKS、EKS 或者 GKE，都具有开箱可用的块存储能力，然而这也不见得就是最好的选择。有很多因素需要考虑，比如说公有云的 StorageClass 的故障转移时间太长。例如在 一个针对 AWS EBS 的故障测试中，加载了卷的 Pod 用了超过五分钟才成功的在另一个节点上启动。Portworx 或者 OpenEBS 这样的云原生存储产品，正在尝试解决这类问题。

本文的目标是使用最常见的 Kubernetes 存储方案，进行基本的性能对比。我觉得在 Azure AKS 上使用下列后端：

AKS 原生 Storageclass：

1.Azure native premium

2.使用 cStor 后端的 OpenEBS

3.Portworx

4.Heketi 管理的 Gluster

5.Rook 管理的 Ceph

Go语言写文件几种方式性能对比

Go语言中写文件有多种方式，这里进行如下几种方式的速度对比：

打开文件，写入内容，关闭文件。如此重复多次

打开文件，写入内容，defer 关闭文件。如此重复多次

打开文件，重复多次写入内容，defer 关闭文件

在VMWare下的Ubuntu 14.04下运行的结果表明：

方式1速度最慢，但是慢的很稳定

方式2比方式1略快，但是重复次数多了后会报错，应该是defer被压栈太多导致系统撑不了太多打开的文件

方式3速度约是前两者的2倍，因为减少了很多打开关闭文件的操作

测试代码如下：

package main
import (    "fmt"
    "os"
    "time")
func benchmarkFileWrite(filename string, n int, index int) (d time.Duration) {
    v := "ni shuo wo shi bu shi tai wu liao le a?"
    os.Remove(filename)
    t0 := time.Now()    switch index {    case 0: // open file and write, then close, repeat n times
        for i := 0; i < n; i++ {
            file, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)            if err != nil {
                fmt.Println(index, i, "open file failed.", err.Error())                break
            }
            file.WriteString(v)
            file.WriteString("\n")
            file.Close()
        }    case 1: // open file and write, defer close, repeat n times
        for i := 0; i < n; i++ {
            file, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)            if err != nil {
                fmt.Println(index, i, "open file failed.", err.Error())                break
            }
            defer file.Close()
            file.WriteString(v)
            file.WriteString("\n")
        }    case 2: // open file and write n times, then close file
        file, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)        if err != nil {
            fmt.Println(index, "open file failed.", err.Error())            break
        }
        defer file.Close()        for i := 0; i < n; i++ {
            file.WriteString(v)
            file.WriteString("\n")
        }
    }
    t1 := time.Now()
    d = t1.Sub(t0)
    fmt.Printf("time of way(%d)=%v\n", index, d)    return d
}
func main() {    const k, n int = 3, 1000
    d := [k]time.Duration{}    for i := 0; i < k; i++ {
        d[i] = benchmarkFileWrite("benchmarkFile.txt", n, i)
    }    for i := 0; i < k-1; i++ {
        fmt.Printf("way %d cost time is %6.1f times of way %d\n", i, float32(d[i])/float32(d[k-1]), k-1)
    }
}

当n=1000时，测试结果如下

  time of way(0)=38.719386ms
  time of way(1)=31.428677ms
  time of way(2)=17.930829ms
  way 0 cost time is    2.2 times of way 2
  way 1 cost time is    1.8 times of way 2

当n=5000时，测试结果如下（因为方式1报错，所以它的时间是错的）

  time of way(0)=170.003521ms  1 1021 open file failed. open benchmarkFile.txt: too many open files
  time of way(1)=32.388994ms
  time of way(2)=77.777936ms
  way 0 cost time is    2.2 times of way 2
  way 1 cost time is    0.4 times of way 2

本文来自：博客园

查看原文：[笔记]Go语言写文件几种方式性能对比