分类 其它 下的文章

什么是SPU?什么是SKU

SPU（Standard Product Unit） 标准产品单元，是一组可复用、易检索的标准化信息的集合。 该集合描述了一个产品的特性，通俗一点讲： 属性值、特性相同的商品就是一组SPU

(╯‵□′)╯︵┻━┻

SKU（Stock Keeping Unit） 库存保有单位，是对每一个产品的唯一标识符；比如说：比如说同一件产品：衣服, 衣服的颜色、尺码、款式就是一组SKU， 颜色、尺码也是一组SKU, 颜色、款式也是一组SKU.


他们两个之间的关系呢就是. 我们所说的商品是一个泛化的东西，比如说shoppingmode 苹果手机，他是有很多种的， shoppingmode iphone4, 5, 6等等， 我们可以将Iphone 看做是手机中的一个商品， 然后 shoppingmode iphone 5s， 确定一个产品，即SPU， 然后在从产品具体细化到， 颜色、尺码等具体的属性就是 一个SKU了，

即： SPU + 具体属性1 + 具体属性2 + 具体属性n = SKU，


一般来说，咱们库存，都是要按照具体属性来的（即，SKU为最小库存单位） 不然店里面缺货了，都不知道该补哪些哪些？ 我要一个shoppingmode 苹果手机？？？5s ？？？？ 嗯？那店长就会说，请问是什么颜色的呢？ 请问是xxxxx

闭嘴，我用SKU存库存了…


自从我开始探索 Python 中惊人的语言功能已经有一段时间了。一开始，我给自己一个挑战，目的是让我练习更多的 Python 语言功能，而不是使用其他编程语言的编程经验。这让事情变得越来越有趣！代码变得越来越简洁，代码看起来更加结构化和规范化。下面我将会介绍这些好处。

通常如下使用场景中会用到 for 循环：

  • 在一个序列来提取一些信息。
  • 从一个序列生成另一个序列。
  • 写 for 已成习惯。

幸运的是，Python 已经有很多工具可以帮助你完成这些工作，你只需要转移你的思路，并以不同的角度来思考它。

通过避免编写 for 循环，你可以获得什么好处：

  • 较少的代码量
  • 更好的代码可读性
  • 更少的缩进（对 Python 还是很有意义的）

我们来看一下下面的代码结构：

# 1
with ...:
    for ...:
        if ...:
            try:
            except:
        else:

在这个例子中，我们正在处理多层嵌套的代码，这很难阅读。这个例子使用了多层嵌套的代码。我在这段代码中发现它无差别使用缩进把管理逻辑（with, try-except）和业务逻辑（for, if）混在一起。如果你遵守只对管理逻辑使用缩进的规范，那么核心业务逻辑应该立刻脱离出来。

"扁平结构比嵌套结构更好" - The Zen of Python

可以使用的已有的工具来替换 for 循环

1. List Comprehension / Generator 表达式

我们来看一个简单的例子。如果你想将一个数组转换为另一个数组：

result = []
for item in item_list:
    new_item = do_something_with(item)
    result.append(item)

如果你喜欢 MapReduce，你也可以使用 map，或者 Python 中的 List Comprehension：

result = [do_something_with(item) for item in item_list]

同样，如果您只想迭代数组中的元素，也可以使用一样的代码 Generator Expression。

result = (do_something_with(item) for item in item_list)

2. 函数

如果您想要将一个数组映射成另外数组，只需调用 map 函数，就可以用一个更高级、更实用的编程方式解决这个问题。

doubled_list = map(lambda x: x * 2, old_list)

如果要将序列减少为单个，请使用 reduce

from functools import reduce
summation = reduce(lambda x, y: x + y, numbers)

另外，许多 Python 内置函数都会使用 iterables：

>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> all(a)
False
>>> any(a)
True
>>> max(a)
9
>>> min(a)
0
>>> list(filter(bool, a))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> set(a)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> dict(zip(a,a))
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
>>> sorted(a, reverse=True)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> str(a)
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'
>>> sum(a)
45

3. Extract Functions or Generators

上述两种方法是很好的处理更简单的逻辑。更复杂的逻辑怎么样？作为程序员，我们编写函数来抽离出复杂的业务。相同的想法适用于此。如果你是这样写的：

results = []
for item in item_list:
    # setups
    # condition
    # processing
    # calculation
    results.append(result)

显然你对一个代码块添加了太多的责任。相反，我建议你做：

def process_item(item):
    # setups
    # condition
    # processing
    # calculation
    return result

results = [process_item(item) for item in item_list]

如果换成嵌套函数会如何

results = []
for i in range(10):
    for j in range(i):
        results.append((i, j))

换成 List Comprehension 来实现是这样的：

results = [(i, j)
           for i in range(10)
           for j in range(i)]

如果你的代码块需要记录一些内部状态

# finding the max prior to the current item
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = []
current_max = 0
for i in a:
    current_max = max(i, current_max)
    results.append(current_max)

# results = [3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

我们使用 generator 来实现这一点：

def max_generator(numbers):
    current_max = 0
    for i in numbers:
        current_max = max(i, current_max)
        yield current_max

a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
results = list(max_generator(a))

读者可能要问 “等等！你在 generator 中用到 for 循环，作弊啊！别急，再看看下面的代码。

不要自己写。itertools 会帮你实现了

这个模块很简单。我相信这个模块在大多数场景中可以替换你原先的 for 循环。例如，最后一个例子可以重写为：

from itertools import accumulate
a = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
resutls = list(accumulate(a, max))

另外，如果要迭代组合序列，则需要使用product()， permutations()， combinations()。

结论

  • 在大多数情况下，您都不需要编写 for 循环。
  • 你应该避免编写 for 循环，这样会有更好的代码可读性。


困惑


最近遇到个问题，有个表的要加个user_id字段，user_id字段可能很大，于是我提mysql工单alter table xxx ADD user_id int(1)。领导看到我的sql工单，于是说：这int(1)怕是不够用吧，接下来是一通解释。

其实这不是我第一次遇到这样的问题了，其中不乏有工作5年以上的老司机。包括我经常在也看到同事也一直使用int(10)，感觉用了int(1)，字段的上限就被限制，真实情况肯定不是这样。


数据说话

我们知道在mysql中 int占4个字节，那么对于无符号的int，最大值是2^32-1 = 4294967295，将近40亿，难道用了int(1)，就不能达到这个最大值吗？





CREATE TABLE `user` (  `id` int(1) unsigned NOT NULL AUTO_INCREMENT,   PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

id字段为无符号的int(1)，我来插入一个最大值看看。



mysql> INSERT INTO `user` (`id`) VALUES (4294967295);Query OK, 1 row affected (0.00 sec)

可以看到成功了，说明int后面的数字，不影响int本身支持的大小，int(1)、int(2)...int(10)没什么区别。

零填充

一般int后面的数字，配合zerofill一起使用才有效。先看个例子：





CREATE TABLE `user` (  `id` int(4) unsigned zerofill NOT NULL AUTO_INCREMENT,   PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

注意int(4)后面加了个zerofill，我们先来插入4条数据。




mysql> INSERT INTO `user` (`id`) VALUES (1),(10),(100),(1000);Query OK, 4 rows affected (0.00 sec)Records: 4  Duplicates: 0  Warnings: 0



分别插入1、10、100、1000 4条数据，然后我们来查询下：











mysql> select * from user;+------+| id   |+------+| 0001 || 0010 || 0100 || 1000 |+------+4 rows in set (0.00 sec)

通过数据可以发现 int(4) + zerofill实现了不足4位补0的现象，单单int(4)是没有用的。而且对于0001这种，底层存储的还是1，只是在展示的会补0。

总结

int后面的数字不能表示字段的长度，int(num)一般加上zerofill，才有效果。

zerofill的作用一般可以用在一些编号相关的数字中，比如学生的编号 001 002 ... 999这种，如果mysql没有零填充的功能，但是你又要格式化输出等长的数字编号时，那么你只能自己处理了。

图片


OkHttp可以说是Android开发中最常见的网络请求框架，OkHttp使用方便，扩展性强，功能强大，OKHttp源码与原理也是面试中的常客。

但是OKHttp的源码内容比较多，想要学习它的源码往往千头万绪，一时抓不住重点。本文从几个问题出发梳理OKHttp相关知识点，以便快速构建OKHttp知识体系，如果对你有用，欢迎点赞~

本文主要包括以下内容：

  1. OKHttp请求的整体流程是怎样的？

  2. OKHttp分发器是怎样工作的？

  3. OKHttp拦截器是如何工作的？

  4. 应用拦截器和网络拦截器有什么区别？

  5. OKHttp如何复用TCP连接？

  6. OKHttp空闲连接如何清除？

  7. OKHttp有哪些优点？

  8. OKHttp框架中用到了哪些设计模式

OKHttp请求整体流程介绍

首先来看一个最简单的Http请求是如何发送的。

   val okHttpClient = OkHttpClient()
   val request: Request = Request.Builder()
       .url("https://www.google.com/")
       .build()

   okHttpClient.newCall(request).enqueue(object :Callback{
       override fun onFailure(call: Call, e: IOException) {
       }

       override fun onResponse(call: Call, response: Response) {
       }
   })

这段代码看起来比较简单，OkHttp请求过程中最少只需要接触OkHttpClient、Request、Call、 Response，但是框架内部会进行大量的逻辑处理。

所有网络请求的逻辑大部分集中在拦截器中，但是在进入拦截器之前还需要依靠分发器来调配请求任务。

关于分发器与拦截器，我们在这里先简单介绍下，后续会有更加详细的讲解。

  • 分发器：内部维护队列与线程池，完成请求调配；

  • 拦截器：五大默认拦截器完成整个请求过程。


图片

整个网络请求过程大致如上所示：

  1. 通过建造者模式构建OKHttpClient与 Request

  2. OKHttpClient通过newCall发起一个新的请求

  3. 通过分发器维护请求队列与线程池，完成请求调配

  4. 通过五大默认拦截器完成请求重试，缓存处理，建立连接等一系列操作

  5. 得到网络请求结果

OKHttp分发器是怎样工作的？

分发器的主要作用是维护请求队列与线程池,比如我们有100个异步请求，肯定不能把它们同时请求，而是应该把它们排队分个类，分为正在请求中的列表和正在等待的列表，等请求完成后，即可从等待中的列表中取出等待的请求，从而完成所有的请求。

而这里同步请求各异步请求又略有不同。

同步请求

synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
}

因为同步请求不需要线程池，也不存在任何限制。所以分发器仅做一下记录。后续按照加入队列的顺序同步请求即可。

异步请求

synchronized void enqueue(AsyncCall call) {
    //请求数最大不超过64,同一Host请求不能超过5个
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost)     {
        runningAsyncCalls.add(call);
        executorService().execute(call);
    } else {
        readyAsyncCalls.add(call);
    }
}

当正在执行的任务未超过最大限制64，同时同一Host的请求不超过5个，则会添加到正在执行队列，同时提交给线程池。否则先加入等待队列。每个任务完成后，都会调用分发器的finished方法，这里面会取出等待队列中的任务继续执行。

OKHttp拦截器是怎样工作的？

经过上面分发器的任务分发，下面就要利用拦截器开始一系列配置了。

### RealCall
  override fun execute(): Response {
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

我们再来看下RealCall的execute方法，可以看出，最后返回了getResponseWithInterceptorChain，责任链的构建与处理其实就是在这个方法里面。

internal fun getResponseWithInterceptorChain(): Response {
    // Build a full stack of interceptors.
    val interceptors = mutableListOf<Interceptor>()
    interceptors += client.interceptors
    interceptors += RetryAndFollowUpInterceptor(client)
    interceptors += BridgeInterceptor(client.cookieJar)
    interceptors += CacheInterceptor(client.cache)
    interceptors += ConnectInterceptor
    if (!forWebSocket) {
      interceptors += client.networkInterceptors
    }
    interceptors += CallServerInterceptor(forWebSocket)

    val chain = RealInterceptorChain(
        call = this,interceptors = interceptors,index = 0
    )
    val response = chain.proceed(originalRequest)
  }

如上所示，构建了一个OkHttp拦截器的责任链。

责任链，顾名思义，就是用来处理相关事务责任的一条执行链，执行链上有多个节点，每个节点都有机会（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。

如上所示责任链添加的顺序及作用如下表所示：

图片

我们的网络请求就是这样经过责任链一级一级的递推下去，最终会执行到CallServerInterceptor的intercept方法，此方法会将网络响应的结果封装成一个Response对象并return。之后沿着责任链一级一级的回溯，最终就回到getResponseWithInterceptorChain方法的返回，如下图所示：

图片

应用拦截器和网络拦截器有什么区别？

从整个责任链路来看，应用拦截器是最先执行的拦截器，也就是用户自己设置request属性后的原始请求，而网络拦截器位于ConnectInterceptor和CallServerInterceptor之间，此时网络链路已经准备好，只等待发送请求数据。它们主要有以下区别。

  1. 首先，应用拦截器在RetryAndFollowUpInterceptor和CacheInterceptor之前，所以一旦发生错误重试或者网络重定向，网络拦截器可能执行多次，因为相当于进行了二次请求，但是应用拦截器永远只会触发一次。另外如果在CacheInterceptor中命中了缓存就不需要走网络请求了，因此会存在短路网络拦截器的情况。

  2. 其次，除了CallServerInterceptor之外，每个拦截器都应该至少调用一次realChain.proceed方法。实际上在应用拦截器这层可以多次调用proceed方法（本地异常重试）或者不调用proceed方法（中断），但是网络拦截器这层连接已经准备好，可且仅可调用一次proceed方法。

  3. 最后，从使用场景看，应用拦截器因为只会调用一次，通常用于统计客户端的网络请求发起情况；而网络拦截器一次调用代表了一定会发起一次网络通信，因此通常可用于统计网络链路上传输的数据。

OKHttp如何复用TCP连接？

ConnectInterceptor的主要工作就是负责建立TCP连接，建立TCP连接需要经历三次握手四次挥手等操作，如果每个HTTP请求都要新建一个TCP消耗资源比较多。

而Http1.1已经支持keep-alive，即多个Http请求复用一个TCP连接，OKHttp也做了相应的优化，下面我们来看下OKHttp是怎么复用TCP连接的。

ConnectInterceptor中查找连接的代码会最终会调用到ExchangeFinder.findConnection方法，具体如下：

### ExchangeFinder
//为承载新的数据流 寻找 连接。寻找顺序是 已分配的连接、连接池、新建连接
private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
    int pingIntervalMillis, boolean connectionRetryEnabled) throws IOException {
  synchronized (connectionPool) {
    // 1.尝试使用 已给数据流分配的连接.（例如重定向请求时，可以复用上次请求的连接）
    releasedConnection = transmitter.connection;
    result = transmitter.connection;

    if (result == null) {
      // 2\. 没有已分配的可用连接，就尝试从连接池获取。（连接池稍后详细讲解）
      if (connectionPool.transmitterAcquirePooledConnection(address, transmitter, null, false)) {
        result = transmitter.connection;
      }
    }
  }

  synchronized (connectionPool) {
    if (newRouteSelection) {
      //3\. 现在有了IP地址，再次尝试从连接池获取。可能会因为连接合并而匹配。（这里传入了routes，上面的传的null）
      routes = routeSelection.getAll();
      if (connectionPool.transmitterAcquirePooledConnection(address, transmitter, routes, false)) {
        foundPooledConnection = true;
        result = transmitter.connection;
      }
    }

  // 4.第二次没成功，就把新建的连接，进行TCP + TLS 握手，与服务端建立连接. 是阻塞操作
  result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,
      connectionRetryEnabled, call, eventListener);

  synchronized (connectionPool) {
    // 5\. 最后一次尝试从连接池获取，注意最后一个参数为true，即要求 多路复用（http2.0）
    //意思是，如果本次是http2.0，那么为了保证 多路复用性，（因为上面的握手操作不是线程安全）会再次确认连接池中此时是否已有同样连接
    if (connectionPool.transmitterAcquirePooledConnection(address, transmitter, routes, true)) {
      // 如果获取到，就关闭我们创建里的连接，返回获取的连接
      result = transmitter.connection;
    } else {
      //最后一次尝试也没有的话，就把刚刚新建的连接存入连接池
      connectionPool.put(result);
    }
  }

  return result;
}

上面精简了部分代码，可以看出，连接拦截器使用了5种方法查找连接。

  1. 首先会尝试使用 已给请求分配的连接。（已分配连接的情况例如重定向时的再次请求，说明上次已经有了连接）

  2. 若没有 已分配的可用连接，就尝试从连接池中匹配获取。因为此时没有路由信息，所以匹配条件：address一致——host、port、代理等一致，且匹配的连接可以接受新的请求。

  3. 若从连接池没有获取到，则传入routes再次尝试获取，这主要是针对Http2.0的一个操作，Http2.0可以复用square.com与square.ca的连接

  4. 若第二次也没有获取到，就创建RealConnection实例，进行TCP + TLS握手，与服务端建立连接。

  5. 此时为了确保Http2.0连接的多路复用性，会第三次从连接池匹配。因为新建立的连接的握手过程是非线程安全的，所以此时可能连接池新存入了相同的连接。

  6. 第三次若匹配到，就使用已有连接，释放刚刚新建的连接；若未匹配到，则把新连接存入连接池并返回。

以上就是连接拦截器尝试复用连接的操作，流程图如下：

图片

OKHttp空闲连接如何清除？

上面说到我们会建立一个TCP连接池，但如果没有任务了，空闲的连接也应该及时清除，OKHttp是如何做到的呢？

  ### RealConnectionPool
  private val cleanupQueue: TaskQueue = taskRunner.newQueue()
  private val cleanupTask = object : Task("$okHttpName ConnectionPool") {
    override fun runOnce(): Long = cleanup(System.nanoTime())
  }

  long cleanup(long now) {
    int inUseConnectionCount = 0;//正在使用的连接数
    int idleConnectionCount = 0;//空闲连接数
    RealConnection longestIdleConnection = null;//空闲时间最长的连接
    long longestIdleDurationNs = Long.MIN_VALUE;//最长的空闲时间

    //遍历连接：找到待清理的连接, 找到下一次要清理的时间（还未到最大空闲时间）
    synchronized (this) {
      for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
        RealConnection connection = i.next();

        //若连接正在使用，continue，正在使用连接数+1
        if (pruneAndGetAllocationCount(connection, now) > 0) {
          inUseConnectionCount++;
          continue;
        }
        //空闲连接数+1
        idleConnectionCount++;

        // 赋值最长的空闲时间和对应连接
        long idleDurationNs = now - connection.idleAtNanos;
        if (idleDurationNs > longestIdleDurationNs) {
          longestIdleDurationNs = idleDurationNs;
          longestIdleConnection = connection;
        }
      }
      //若最长的空闲时间大于5分钟 或 空闲数 大于5，就移除并关闭这个连接
      if (longestIdleDurationNs >= this.keepAliveDurationNs
          || idleConnectionCount > this.maxIdleConnections) {
        connections.remove(longestIdleConnection);
      } else if (idleConnectionCount > 0) {
        // else，就返回 还剩多久到达5分钟，然后wait这个时间再来清理
        return keepAliveDurationNs - longestIdleDurationNs;
      } else if (inUseConnectionCount > 0) {
        //连接没有空闲的，就5分钟后再尝试清理.
        return keepAliveDurationNs;
      } else {
        // 没有连接，不清理
        cleanupRunning = false;
        return -1;
      }
    }
    //关闭移除的连接
    closeQuietly(longestIdleConnection.socket());

    //关闭移除后 立刻 进行下一次的 尝试清理
    return 0;
  }

思路还是很清晰的：

  1. 在将连接加入连接池时就会启动定时任务。

  2. 有空闲连接的话，如果最长的空闲时间大于5分钟或空闲数大于5，就移除关闭这个最长空闲连接；如果空闲数不大于5且最长的空闲时间不大于5分钟，就返回到5分钟的剩余时间，然后等待这个时间再来清理。

  3. 没有空闲连接就等5分钟后再尝试清理。

  4. 没有连接不清理。

流程如下图所示：

图片

OKHttp有哪些优点？

  1. 使用简单，在设计时使用了外观模式，将整个系统的复杂性给隐藏起来，将子系统接口通过一个客户端OkHttpClient统一暴露出来。

  2. 扩展性强，可以通过自定义应用拦截器与网络拦截器，完成用户各种自定义的需求

  3. 功能强大，支持Spdy、Http1.X、Http2、以及WebSocket等多种协议

  4. 通过连接池复用底层TCP(Socket)，减少请求延时

  5. 无缝的支持GZIP减少数据流量

  6. 支持数据缓存，减少重复的网络请求

  7. 支持请求失败自动重试主机的其他ip，自动重定向

OKHttp框架中用到了哪些设计模式？

  1. 构建者模式：OkHttpClient与Request的构建都用到了构建者模式。

  2. 外观模式：OkHttp使用了外观模式,将整个系统的复杂性给隐藏起来，将子系统接口通过一个客户端OkHttpClient统一暴露出来。

  3. 责任链模式：OKHttp的核心就是责任链模式，通过5个默认拦截器构成的责任链完成请求的配置。

  4. 享元模式：享元模式的核心即池中复用，OKHttp复用TCP连接时用到了连接池，同时在异步请求中也用到了线程池。


k8s 镜像仓库 harbor 环境部署

GitHub 地址：https://github.com/helm/helm/releases
这使用 helm 安装，所以得先安装 helm

1）安装 helm

mkdir -p /opt/k8s/helm && cd /opt/k8s/helm
wget https://get.helm.sh/helm-v3.9.0-rc.1-linux-amd64.tar.gz
tar -xf helm-v3.9.0-rc.1-linux-amd64.tar.gz
ln -s /opt/k8s/helm/linux-amd64/helm /usr/bin/helm
helm version
helm help

2）配置 hosts

192.168.0.120 myharbor.com

3）创建 stl 证书

mkdir /opt/k8s/helm/stl && cd /opt/k8s/helm/stl
# 生成 CA 证书私钥
openssl genrsa -out ca.key 4096
# 生成 CA 证书
openssl req -x509 -new -nodes -sha512 -days 3650 \
 -subj "/C=CN/ST=Guangdong/L=Shenzhen/O=harbor/OU=harbor/CN=myharbor.com" \
 -key ca.key \
 -out ca.crt
# 创建域名证书，生成私钥
openssl genrsa -out myharbor.com.key 4096
# 生成证书签名请求 CSR
openssl req -sha512 -new \
    -subj "/C=CN/ST=Guangdong/L=Shenzhen/O=harbor/OU=harbor/CN=myharbor.com" \
    -key myharbor.com.key \
    -out myharbor.com.csr
# 生成 x509 v3 扩展
cat > v3.ext <<-EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]
DNS.1=myharbor.com
DNS.2=*.myharbor.com
DNS.3=hostname
EOF
#创建 Harbor 访问证书
openssl x509 -req -sha512 -days 3650 \
    -extfile v3.ext \
    -CA ca.crt -CAkey ca.key -CAcreateserial \
    -in myharbor.com.csr \
    -out myharbor.com.crt

4）安装 ingress

ingress 官方网站：https://kubernetes.github.io/ingress-nginx/
ingress 仓库地址：https://github.com/kubernetes/ingress-nginx
部署文档：https://kubernetes.github.io/ingress-nginx/deploy/

1、通过 helm 部署

helm upgrade --install ingress-nginx ingress-nginx \
  --repo https://kubernetes.github.io/ingress-nginx \
  --namespace ingress-nginx --create-namespace

2、通过 YAML 文件安装（本章使用这个方式安装 ingress）

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.2.0/deploy/static/provider/cloud/deploy.yaml

如果下载镜像失败，可以用以下方式修改镜像地址再安装

牛逼啊！接私活必备的 N 个开源项目！赶快收藏
# 可以先把镜像下载，再安装
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/nginx-ingress-controller:v1.2.0
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1

wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.2.0/deploy/static/provider/cloud/deploy.yaml
# 修改镜像地址
sed -i 's@k8s.gcr.io/ingress-nginx/controller:v1.2.0\(.*\)@registry.cn-hangzhou.aliyuncs.com/google_containers/nginx-ingress-controller:v1.2.0@' deploy.yaml
sed -i 's@k8s.gcr.io/ingress-nginx/kube-webhook-certgen:v1.1.1\(.*\)$@registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1@' deploy.yaml

###还需要修改两地方
#1、kind: 类型修改成DaemonSet，replicas: 注销掉，因为DaemonSet模式会每个节点运行一个pod
#2、在添加一条：hostnetwork：true
#3、把LoadBalancer修改成NodePort
#4、在--validating-webhook-key下面添加- --watch-ingress-without-class=true
#5、设置master节点可调度
kubectl taint nodes k8s-master-168-0-113 node-role.kubernetes.io/control-plane:NoSchedule-
kubectl taint nodes k8s-master2-168-0-116 node-role.kubernetes.io/control-plane:NoSchedule-

kubectl apply -f deploy.yaml

图片

5）安装 nfs

1、所有节点安装 nfs

yum -y install  nfs-utils rpcbind

2、在 master 节点创建共享目录并授权

mkdir /opt/nfsdata
# 授权共享目录
chmod 666 /opt/nfsdata

3、配置 exports 文件

cat > /etc/exports<<EOF
/opt/nfsdata *(rw,no_root_squash,no_all_squash,sync)
EOF
# 配置生效
exportfs -r

exportfs 命令

常用选项
-a 全部挂载或者全部卸载
-r 重新挂载
-u 卸载某一个目录
-v 显示共享目录 以下操作在服务端上

4、启动 rpc 和 nfs（客户端只需要启动 rpc 服务）（注意顺序）

systemctl start rpcbind
systemctl start nfs-server
systemctl enable rpcbind
systemctl enable nfs-server

查看

showmount -e
# VIP
showmount -e 192.168.0.120

-e 显示 NFS 服务器的共享列表
-a 显示本机挂载的文件资源的情况 NFS 资源的情况
-v 显示版本号

5、客户端

# 安装
yum -y install  nfs-utils rpcbind
# 启动rpc服务
systemctl start rpcbind
systemctl enable rpcbind
# 创建挂载目录
mkdir /mnt/nfsdata
# 挂载
echo "192.168.0.120:/opt/nfsdata /mnt/nfsdata     nfs    defaults  0 1">> /etc/fstab
mount -a

6、rsync 数据同步

【1】rsync 安装
# 两端都得安装
yum -y install rsync
【2】配置

在/etc/rsyncd.conf 中添加

cat >/etc/rsyncd.conf<<EOF
uid = root
gid = root
#禁锢在源目录
use chroot = yes
#监听地址
address = 192.168.0.113
#监听地址tcp/udp 873，可通过cat /etc/services | grep rsync查看
port 873
#日志文件位置
log file = /var/log/rsyncd.log
#存放进程 ID 的文件位置
pid file = /var/run/rsyncd.pid
#允许访问的客户机地址
hosts allow = 192.168.0.0/16
#共享模块名称
[nfsdata]
#源目录的实际路径
path = /opt/nfsdata
comment = Document Root of www.kgc.com
#指定客户端是否可以上传文件，默认对所有模块为 true
read only = yes
#同步时不再压缩的文件类型
dont compress = *.gz *.bz2 *.tgz *.zip *.rar *.z
#授权账户，多个账号以空格分隔，不加则为匿名，不依赖系统账号
auth users = backuper
#存放账户信息的数据文件
secrets file = /etc/rsyncd_users.db
EOF

配置 rsyncd_users.db

cat >/etc/rsyncd_users.db<<EOF
backuper:123456
EOF
#官方要求，最好只是赋权600！
chmod 600 /etc/rsyncd_users.db
【3】rsyncd.conf 常用参数详解

rsyncd.conf 参数


rsyncd.conf 参数参数说明
uid=rootrsync 使用的用户。
gid=rootrsync 使用的用户组（用户所在的组）
use chroot=no如果为 true，daemon 会在客户端传输文件前“chroot to the path”。这是一种安全配置，因为我们大多数都在内网，所以不配也没关系
max connections=200设置最大连接数，默认 0，意思无限制，负值为关闭这个模块
timeout=400默认为 0，表示 no timeout，建议 300-600（5-10 分钟）
pid filersync daemon 启动后将其进程 pid 写入此文件。如果这个文件存在，rsync 不会覆盖该文件，而是会终止
lock file指定 lock 文件用来支持“max connections”参数，使得总连接数不会超过限制
log file不设或者设置错误，rsync 会使用 rsyslog 输出相关日志信息
ignore errors忽略 I/O 错误
read only=false指定客户端是否可以上传文件，默认对所有模块为 true
list=false是否允许客户端可以查看可用模块列表，默认为可以
hosts allow指定可以联系的客户端主机名或和 ip 地址或地址段，默认情况没有此参数，即都可以连接
hosts deny指定不可以联系的客户端主机名或 ip 地址或地址段，默认情况没有此参数，即都可以连接
auth users指定以空格或逗号分隔的用户可以使用哪些模块，用户不需要在本地系统中存在。默认为所有用户无密码访问
secrets file指定用户名和密码存放的文件，格式；用户名；密码，密码不超过 8 位
[backup]这里就是模块名称，需用中括号扩起来，起名称没有特殊要求，但最好是有意义的名称，便于以后维护
path这个模块中，daemon 使用的文件系统或目录，目录的权限要注意和配置文件中的权限一致，否则会遇到读写的问题


【4】rsync 常用命令参数详解
rsync --help

rsync [选项]  原始位置   目标位置

常用选项    说明
-r    递归模式，包含目录及子目录中的所有文件
-l    对于符号链接文件仍然复制为符号链接文件
-v    显示同步过程的详细信息
-z    在传输文件时进行压缩goD
-p    保留文件的权限标记
-a    归档模式，递归并保留对象属性，等同于-rlpt
-t    保留文件的时间标记
-g    保留文件的属组标记（仅超级用户使用）
-o    保留文件的属主标记（仅超级用户使用）
-H    保留硬链接文件
-A    保留ACL属性信息
-D    保留设备文件及其他特殊文件
--delete  删除目标位置有而原始位置没有的文件
--checksum  根据对象的校验和来决定是否跳过文件
【5】启动服务（数据源机器）
#rsync监听端口：873
#rsync运行模式：C/S
rsync --daemon --config=/etc/rsyncd.conf
netstat -tnlp|grep :873
【6】执行命令同步数据
# 在目的机器上执行
# rsync -avz 用户名@源主机地址/源目录 目的目录
rsync -avz root@192.168.0.113:/opt/nfsdata/* /opt/nfsdata/
【7】crontab 定时同步
# 配置crontab， 每五分钟同步一次，这种方式不好
*/5 * * * * rsync -avz root@192.168.0.113:/opt/nfsdata/* /opt/nfsdata/

【温馨提示】crontab 定时同步数据不太好，可以使用rsync+inotify做数据实时同步，这里篇幅有点长了，先不讲，如果后面有时间会出一篇单独文章来讲。

6）创建 nfs provisioner 和持久化存储 SC

【温馨提示】这里跟我之前的文章有点不同，之前的方式也不适用新版本。

GitHub 地址：https://github.com/kubernetes-sigs/nfs-subdir-external-provisioner

helm 部署 nfs-subdir-external-provisioner

1、添加 helm 仓库

helm repo add nfs-subdir-external-provisioner https://kubernetes-sigs.github.io/nfs-subdir-external-provisioner/

2、helm 安装 nfs provisioner

【温馨提示】默认镜像是无法访问的，这里使用 dockerhub 搜索到的镜像willdockerhub/nfs-subdir-external-provisioner:v4.0.2，还有就是 StorageClass 不分命名空间，所有在所有命名空间下都可以使用。

helm install nfs-subdir-external-provisioner nfs-subdir-external-provisioner/nfs-subdir-external-provisioner \
  --namespace=nfs-provisioner \
  --create-namespace \
  --set image.repository=willdockerhub/nfs-subdir-external-provisioner \
  --set image.tag=v4.0.2 \
  --set replicaCount=2 \
  --set storageClass.name=nfs-client \
  --set storageClass.defaultClass=true \
  --set nfs.server=192.168.0.120 \
  --set nfs.path=/opt/nfsdata

【温馨提示】上面 nfs.server 设置为 VIP，可实现高可用。

3、查看

kubectl get pods,deploy,sc -n nfs-provisioner

图片

7）部署 Harbor（Https 方式）

1、创建 Namespace

kubectl create ns harbor

2、创建证书秘钥

kubectl create secret tls myharbor.com --key myharbor.com.key --cert myharbor.com.crt -n harbor
kubectl get secret myharbor.com -n harbor

3、添加 Chart 库

helm repo add harbor https://helm.goharbor.io

4、通过 helm 安装 harbor

helm install myharbor --namespace harbor harbor/harbor \
  --set expose.ingress.hosts.core=myharbor.com \
  --set expose.ingress.hosts.notary=notary.myharbor.com \
  --set-string expose.ingress.annotations.'nginx\.org/client-max-body-size'="1024m" \
  --set expose.tls.secretName=myharbor.com \
  --set persistence.persistentVolumeClaim.registry.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.jobservice.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.database.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.redis.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.trivy.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.chartmuseum.storageClass=nfs-client \
  --set persistence.enabled=true \
  --set externalURL=https://myharbor.com \
  --set harborAdminPassword=Harbor12345

这里稍等一段时间在查看资源状态

kubectl get ingress,svc,pods,pvc -n harbor

图片

5、ingress 没有 ADDRESS 问题解决

【分析】，发现"error: endpoints “default-http-backend” not found"

cat << EOF > default-http-backend.yaml
---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: default-http-backend
  labels:
    app: default-http-backend
  namespace: harbor
spec:
  replicas: 1
  selector:
    matchLabels:
      app: default-http-backend
  template:
    metadata:
      labels:
        app: default-http-backend
    spec:
      terminationGracePeriodSeconds: 60
      containers:
      - name: default-http-backend
        # Any image is permissible as long as:
        # 1. It serves a 404 page at /
        # 2. It serves 200 on a /healthz endpoint
        image: registry.cn-hangzhou.aliyuncs.com/google_containers/defaultbackend:1.4
#        image: gcr.io/google_containers/defaultbackend:1.4
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 30
          timeoutSeconds: 5
        ports:
        - containerPort: 8080
        resources:
          limits:
            cpu: 10m
            memory: 20Mi
          requests:
            cpu: 10m
            memory: 20Mi
---

apiVersion: v1
kind: Service
metadata:
  name: default-http-backend
  namespace: harbor
  labels:
    app: default-http-backend
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: default-http-backend
EOF
kubectl apply -f default-http-backend.yaml

6、卸载重新部署

# 卸载
helm uninstall myharbor -n harbor
kubectl get pvc -n harbor| awk 'NR!=1{print $1}' | xargs kubectl delete pvc -n harbor

# 部署
helm install myharbor --namespace harbor harbor/harbor \
  --set expose.ingress.hosts.core=myharbor.com \
  --set expose.ingress.hosts.notary=notary.myharbor.com \
  --set-string expose.ingress.annotations.'nginx\.org/client-max-body-size'="1024m" \
  --set expose.tls.secretName=myharbor.com \
  --set persistence.persistentVolumeClaim.registry.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.jobservice.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.database.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.redis.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.trivy.storageClass=nfs-client \
  --set persistence.persistentVolumeClaim.chartmuseum.storageClass=nfs-client \
  --set persistence.enabled=true \
  --set externalURL=https://myharbor.com \
  --set harborAdminPassword=Harbor12345

图片

5、访问 harbor

https://myharbor.com
账号/密码：admin/Harbor12345
图片

6、harbor 常见操作

【1】创建项目 bigdata

图片

【2】配置私有仓库

在文件/etc/docker/daemon.json添加如下内容：

"insecure-registries":["https://myharbor.com"]

重启 docker

systemctl restart docker
【3】服务器上登录 harbor
docker login https://myharbor.com
#账号/密码：admin/Harbor12345

图片

【4】打标签并把镜像上传到 harbor
docker tag rancher/pause:3.6 myharbor.com/bigdata/pause:3.6
docker push myharbor.com/bigdata/pause:3.6

7、修改 containerd 配置

以前使用 docker-engine 的时候，只需要修改/etc/docker/daemon.json 就行，但是新版的 k8s 已经使用 containerd 了，所以这里需要做相关配置，要不然 containerd 会失败。证书（ca.crt）可以在页面上下载：
图片
创建域名目录

mkdir /etc/containerd/myharbor.com
cp ca.crt /etc/containerd/myharbor.com/

配置文件：/etc/containerd/config.toml

[plugins."io.containerd.grpc.v1.cri".registry]
      config_path = ""

      [plugins."io.containerd.grpc.v1.cri".registry.auths]

      [plugins."io.containerd.grpc.v1.cri".registry.configs]
        [plugins."io.containerd.grpc.v1.cri".registry.configs."myharbor.com".tls]
          ca_file = "/etc/containerd/myharbor.com/ca.crt"
        [plugins."io.containerd.grpc.v1.cri".registry.configs."myharbor.com".auth]
          username = "admin"
          password = "Harbor12345"

      [plugins."io.containerd.grpc.v1.cri".registry.headers]

      [plugins."io.containerd.grpc.v1.cri".registry.mirrors]
        [plugins."io.containerd.grpc.v1.cri".registry.mirrors."myharbor.com"]
          endpoint = ["https://myharbor.com"]

图片
重启 containerd

#重新加载配置
systemctl daemon-reload
#重启containerd
systemctl restart containerd

简单使用

# 把docker换成crictl 就行，命令都差不多
crictl pull myharbor.com/bigdata/mysql:5.7.38

执行 crictl 报如下错误的解决办法

WARN[0000] image connect using default endpoints: [unix:///var/run/dockershim.sock unix:///run/containerd/containerd.sock unix:///run/crio/crio.sock unix:///var/run/cri-dockerd.sock]. As the default settings are now deprecated, you should set the endpoint instead.
ERRO[0000] unable to determine image API version: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing dial unix /var/run/dockershim.sock: connect: no such file or directory"

这个报错是 docker 的报错，这里没使用，所以这个错误不影响使用，但是还是解决好点，解决方法如下：

cat <<EOF> /etc/crictl.yaml
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
EOF

再次拉取镜像

crictl pull myharbor.com/bigdata/mysql:5.7.38

图片

Kubernetes（k8s）最新版最完整版基础环境部署+master 高可用实现详细步骤就到这里了，有疑问的小伙伴欢迎给我留言哦~


  1. 1
  2. ...
  3. 1216
  4. 1217
  5. 1218
  6. 1219
  7. 1220
  8. 1221
  9. 1222
  10. ...
  11. 1232