1.UniRx 簡介

UniRx 是一個 Unity3D 的編程框架。它專註於解決時間上異步的邏輯，使得異步邏輯的實現更加簡潔和優雅。

簡潔優雅如何體現？

比如，實現一個“只處理第一次鼠標點擊事件”這個功能，使用 UniRx 實現如下:

Observable.EveryUpdate()
			.Where(_ => Input.GetMouseButtonUp(0))
			.First()
			.Subscribe(_ => { // do something   });

代碼做的事情很簡單:

1. 開啟一個 Update 的事件監聽。
2. 每次 Update 事件被調用時，進行鼠標是否抬起的判斷。
3. 如果判斷通過，則進行計數，並且只獲取第一次點擊事件。
4. 訂閱/處理事件。

如果在 Unity 中，使用傳統的方式實現如上功能，首先要創建一個成員變量來記錄點擊次數/是否點擊過，然後在腳本中創建一個 Update 方法來監聽鼠標抬起的事件。

如果在 Update 方法中，除了實現鼠標事件監聽這個功能之外，還要實現其他的功能。那麼 Update 里就會充斥着大量的狀態判斷等邏輯。代碼非常不容易閱讀。

而 UniRx 提供了一種編程思維，使得平時一些比較難以實現的異步邏輯（比如以上這種），使用 UniRx 輕鬆搞定，並且不失代碼的可讀性。

當然 UniRx 的強大不僅僅如此。

它還可以：

• 優雅實現 MVP（MVC）架構模式。
• 對 UGUI/Unity API 提供了增強，很多需要寫大量代碼的 UI 邏輯，使用 UniRx 優雅實現。
• 輕鬆完成非常複雜的異步任務處理。
• ……

最最重要的是，它可以提高我們的編碼效率，同時還給我們的大腦提供一個強有力的編程模型。而 UniRx 本身的源碼非常值得研究學習，就連大名鼎鼎的 uFrame 框架，在 1.6 版本之後，使用 UniRx 進行了大幅重構，其事件/數據綁定層使用 UniRx 強力驅動。

筆者的 QFramework 也同樣引入了 UniRx，有一大批的框架用戶都是因為支持了 UniRx 慕名而來。

為什麼要用 UniRx ?

UniRx 就是 Unity 版本的 Reactive Extensions，Reactive Extensions 中文意思是：響應式擴展，響應式指的是觀察者和定時器，擴展指的是 LINQ 的操作符。Reactive Extensions 以擅長處理時間上異步的邏輯、以及極簡的 API 風格而聞名。

我們都知道，遊戲很多的系統都是在時間上異步的，所以 Unity 開發者所需要實現的異步邏輯是非常多的。這也是為什麼 Unity 官方在引擎層實現了 Coroutine（協程）這樣的概念。

在遊戲中，像動畫的播放、聲音的播放、網絡請求、資源加載/卸載、Tween 動畫、場景過渡等都是在時間上異步的邏輯。甚至是遊戲循環（Every Update、OnCollisionEnter 等）、傳感器數據（Kinect、Leap Motion、VR Input 等）都是時間上異步的邏輯（事件）。

當我們在項目中實現以上的邏輯的時候，往往使用的方式是用大量的回調實現，最終隨着項目的擴張會導致傳說中的”回調地獄”。

相對較好的方法則是使用消息/事件進行實現，結果導致“消息滿天飛”，導致代碼非常難以閱讀。

以上的任務使用 Coroutine 也是非常不錯的，但是 Coroutine 在 Unity 使用的時候，需要定義一個方法。寫起來是非常面向過程的。當邏輯稍微複雜一點，就很容易造成 Coroutine 嵌套 Coroutine，代碼是非常不容易閱讀的（強耦合）。

而 UniRx 的出現剛好解決了這個問題，它介於回調和事件之間。

它有事件的概念，只不過它的事件是像流水一樣流過來，而我們要做的則是簡單地對這些事件進行組織、變換、過濾、合併就可以得到我們想要的結果了。

它也用掉了回調，只不過它的回調是在事件經過組織之後，只需要調用一次就可以進行事件處理了。

它的原理和 Coroutine （迭代器模式）、LINQ 非常相似，但是比 Coroutine 強大得多。

UniRx 將時間上異步的事件轉化為響應式的事件序列，通過 LINQ操作可以很簡單地組合起來。

為什麼要用 UniRx？ 答案就是遊戲本身有大量的在時間上異步的邏輯，而 UniRx 恰好擅長處理這類邏輯，使用 UniRx 可以節省我們的時間，同時讓代碼更簡潔易讀。

Rx 只是一套標準，其他的語言也有實現，如果在 Unity 中熟悉了這套標準，那麼在未來，大家在做別的語言的項目的時候，很容易獲得 Rx 的能力。

專欄內容：

1. 實踐並講解開發中最常用的 UniRx API。
2. 對 UniRx 進行一個全方面的簡介。
3. 在每個階段結束后就會結合所學的知識進行項目實踐。
4. UniRx 操作符大全。
5. UniRx 源碼閱讀。
6. UniRx 背後的設計原理及設計模式學習。
7. LINQ、Coroutine 底層原理剖析。
8. BindingsRx、uFrame 源碼閱讀。

OK，讓我們從下一篇開始，感受一下 UniRx 的魅力吧。

知識地圖

2.定時功能實現

在 Unity 開發中，延時是我們經常要實現的功能，這個功能對於有點經驗的開發者來說不難。

最常見的實現方式如下：

using UnityEngine;

public class CommonDelayExample : MonoBehaviour
{
	private float mStartTime;

	void Start()
	{
		mStartTime = Time.time;
	}

	void Update()
	{
		if (Time.time - mStartTime > 5)
		{
			DoSomething();
			// 避免再次執行
			mStartTime = float.MaxValue;
		}
	}

	void DoSomething()
	{
		Debug.Log("DoSomething");
	}
}

這是很多初學者剛入門時候的實現方式，而初學者們隨着深入學習後來接觸到了 Coroutine（協程），使用 Coroutine 實現定時功能會更容易，而且也是更好的選擇，實現如下：

using System;
using System.Collections;
using UnityEngine;

public class CoroutineDelayExample : MonoBehaviour
{
	void Start()
	{
		StartCoroutine(Timer(5, DoSomething));
	}

	IEnumerator Timer(float seconds, Action callback)
	{
		yield return new WaitForSeconds(seconds);
		callback();
	}

	void DoSomething()
	{
		Debug.Log("DoSomething");
	}
}

協程已經把代碼精簡了很多，不過接下來有更厲害的，使用 UniRx。

代碼如下：

Observable.Timer(TimeSpan.FromSeconds(5)).Subscribe(_ => { /* do something */ });

當然以上代碼是沒有和 MonoBehaviour 進行生命周期綁定的，也就是說當 MonoBehaviour 銷毀了之後，這個定時邏輯可能還在執行，這樣就會有造成空指針異常的風險。

要解決也很簡單，代碼如下:

Observable.Timer(TimeSpan.FromSeconds(5))
		.Subscribe(_ => { /* do something */ })
		.AddTo(this);

只要加上一個 AddTo(this) 就可以了。
這樣，當 this(MonoBehaviour) Destroy 的時候，這個延時邏輯也會銷毀掉，從而避免造成空指針異常。

三行代碼，寫下來大約 20 秒的時間，就搞定了一個實現起來比較麻煩的邏輯。

今天的內容就這些。

知識地圖

更多內容

• QFramework 地址：https://github.com/liangxiegame/QFramework
• QQ 交流群：623597263
• 涼鞋的主頁：https://liangxiegame.com/zhuanlan
• 關注公眾號：liangxiegame 獲取第一時間更新通知及更多的免費內容。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

引子

 有一本講諾貝爾獎獲得者，物理學家費曼的書，叫做《發現的樂趣》，書中寫到一個費曼小時候的故事：

 “我們家有《大不列顛百科全書》，我還是小孩子的時候，父親就常常讓我坐在他腿上，給我讀些《大不列顛百科全書》。比如說，我們讀關於恐龍的部分，書上可能講雷龍或其他什麼龍，書上會說：“這傢伙有 25 英尺高，腦袋寬 6 英尺。” 

這時父親就停下來，說：“我們來看看這句話什麼意思。這句話的意思是：假如它站在我們家的前院里，它是那麼高，高到足以把頭從窗戶伸進來。不過呢，它也可能遇到點麻煩，因為它的腦袋比窗戶稍微寬了些，要是它伸進頭來，會擠破窗戶。 

費曼說：凡是我們讀到的東西，我們都盡量把它轉化成某種現實，從這裏我學到一個本領——凡我所讀的內容，我總設法通過某種轉換，弄明白它究竟什麼意思，它到底在說什麼。

 

費曼技巧

 

費曼技巧，或者說費曼學習法是一種以教促學的方法，一共有四步（已經知道的可以無視，直接跳過）: 

(1) 選擇新概念/新知識， 自己先去學習它。 

(2) 假裝當一個老師，去教授別人 

想象你面對一群小白，怎麼把這個概念講給他們聽，讓他們理解呢？ 

把你講解的思路也寫到紙上，如果實在不想寫，可以說出來。 

非常重要！！！不要讓你的思路停留在大腦中，因為大腦中對於知識點之間的關聯會有些想當然的、錯誤的假設，說出來或者寫出來能找到這些“盲點”！！

 

(3) 如果你在教授的過程中遇到了麻煩，卡了殼，返回去學習。 

重新去看書，搜相關資料，問別人，倒逼自己把這個概念搞清楚， 然後回到第二步，繼續給小白講授。

 

(4) 簡化你的語言。 

目標是用你自己的語言，非專業的詞彙去解釋這個概念。盡量做到簡單直白，或者找到比喻來表達。 

非常簡單的過程，對吧？ 

 

實戰演練

我們來用個例子來演練一下，有請碼農翻身頭號主人公張大胖出場。 

張大胖正在學習Java，這一天他遇到了一個新的概念：“動態代理”  （注意是學習這個概念，不是具體實現）， 非常抽象，在日常編程中幾乎不會直接使用，理解起來有難度。

 

第一步，自學

 張大胖看了動態代理的介紹，書上列舉出一堆煩人的代碼來展示這個東西是怎麼使用的，比如有個接口(IHelloWorld)及其實現類(HelloWorld)， 然後有個InvocationHandler的實現，最後用Proxy.newProxyInstance(….)創建一個新的類出來，這些都是什麼鬼？啰里啰唆的。

 

第二步，張大胖嘗試教一下小白(當然這裏的小白至少得懂點兒Java)

 

張大胖：動態代理嘛，很簡單，就是給定一個接口和實現類，再加上一個InvocationHandler ， 動態代理這個技術可以在運行時創建一個新的代理類出來。 

小白：張老師， 新的代理類有什麼用？ 

張大胖：舉個例子，有個叫IHelloWorld接口及其實現類HelloWorld，它有一個叫sayHello()的方法。可以在sayHello()之前和之後，額外加一些日誌的輸出。 

（在講解一個概念的時候，舉例和類比很重要，人類習慣於通過例子來學習，從具體走向抽象） 

小白：那我直接寫一個新的類，比如HelloWorldEx，把日誌輸出添加到其中不就行了，為什麼還要用Proxy.newProxyInstance（……）這麼麻煩的方法？

public class HelloWorldEx implements IHelloWorld{
    IHelloWorld hw;
    public HelloWorldEx(IHelloWorld hw){
        this.hw = hw;
    }    
    public void sayHello(){        
        Logger.startLog();
        hw.sayHello();
        Logger.endLog();
    }
}

　　

張大胖無法回答這個問題，卡殼了！ 

第三步，回過頭去看書，學習。

書中也沒有解釋，唉！ 

仔細想一想，手動寫一個類HelloWorldEx和用Proxy.newProxyInstance來創建，區別到底是什麼？ 

實現的功能是相同的，但是HelloWorldEx需要事先寫好，編譯后不能改了，相當於寫死了！如果我想對Order類，Employee類，Department類，也想加點兒日誌，還得寫個OrderEx，EmployeeEx，DepartmentEx的類，太麻煩了！ 

而Proxy.newProxyInstance這種方法，可以在程序運行的時候為任意類動態地創建增強的類。 

事先寫死的叫做靜態代理，Proxy.newProxyInstance這種方式叫做動態代理，更加靈活。 

張大胖覺得這麼解釋就通了。 

小白：為什麼要創建新的代理類，那個Proxy.newProxyInstance不能直接修改老的HelloWorld類嗎？ 

張大胖再度卡殼，上網搜索，找到了答案，和Python,Ruby等方法不同，Java本質是一個靜態類型的語言，class一旦被裝入JVM，是不能修改，添加，刪除方法的，既然老的class不能修改，只能通過代理的方式來創建新的類了。 

小白：懂了，這個技術主要用在什麼地方啊? 難道只是加個日誌？ 

張大胖第三次卡殼，只好再次搜索。 

原來動態代理使用得最多的是AOP，AOP中經常會以聲明的方式提出這樣的要求： 

某個包下所有add開頭的方法，在執行之前都要調用Logger.startLog()方法，在執行之後都要調用Logger.endLog()方法。 

或者對於所有以Service結尾的類，所有的方法執行之前都要調用tx.begin()，執行之後都要調用tx.commit(), 如果拋出異常的話調用tx.rollback()。

 

到此為止，張大胖可以這樣來給小白講述了： 

你不是用過Spring AOP嗎？AOP中經常有這樣的需求……  ，Spring想添加這些日誌和事務的功能，但是卻沒有辦法去修改用戶的類，它是框架啊，一是不知道用戶類的源碼，二是Java不允許再修改裝載入JVM的class。 

沒辦法，Spring只好在運行時找到用戶的類，然後操作字節碼動態創建一個新類，新類會對原有的類進行增強，添加日誌，事務這些功能，注意啊，這些都是在內存中動態創建的。 

這個技術就是Java的動態代理，不過它有個前提要求，就是用戶的類需要實現接口才行。我用一個簡單的例子給你說下，你就明白細節了……

 

第四步，簡化，比喻

上面的講解從文字上來說還是非常啰嗦的，用了很大篇幅來講解“為什麼”，因為理解了why ，剩下的就是細節了。  

如果你徹底理解了以後，動態代理的技術細節會在大腦中會建立這麼一幅圖景：

 

$HelloWorld100就是那個代理類，它和HelloWorld都實現了IHelloWorld這個接口。 

如果一定要用個比喻來說，它們倆就是“兄弟關係”，CgLib提供了另外一種對現有類增強的辦法，動態生成的類繼承了現有的類，兩者是“父子關係”。

  

小結

 怎麼樣？用這種（假裝）教授別人，層層遞進、自我逼問的方法是不是很有效果？收益很大？  

用這種辦法，實際上就是逼着你把大腦中的盲點和一些想當然的假設給暴露出來，效果要比單純地閱讀和記憶好得多，趕緊在學習中試一下吧！

  

更多精彩文章，盡在碼農翻身

 

我是一個線程

TCP/IP之大明郵差

一個故事講完Https

CPU 阿甘

Javascript: 一個屌絲的逆襲

微服務把我坑了

如何降低程序員的工資？

程序員，你得選准跑路的時間！

兩年，我學會了所有的編程語言！

一直CRUD，一直996，我煩透了，我要轉型

字節碼萬歲！

上帝託夢給我說：一切皆文件

Node.js :我只需要一個店小二

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?

長話短說，今天分享我為前後端分離項目搭建Gitlab CI/CD流程的一些額外經驗。

Before

Gitlab-ci是Gitlab提供的CI/CD特性，結合Gitlab簡單友好的配置界面，能愉悅的在Gitlab界面查看管道執行流程，並自然流暢的推動敏捷開發流程。
Gitlab-CI/CD的核心是搭建Gitlab Runner、編寫.gitlab-ci.yaml文件。
詳細示例請參考：Gitlab CI/CD+ASP.NETCore.

本次前後端兩個項目使用同一個Gitlab Runner(shell模式)，前端項目的gitlab-ci.yaml構建Job如圖：

Round 1

單個Gitlab Runner可為多個項目提供構建服務，

gitlab-Runner register命令只能接受一個註冊token，當時為支持多個項目，花了不少冤枉心思倒騰Gitlab Runner.

你可以為註冊的項目解鎖Runner，這樣Girlab Runner就可以為其他項目提供構建：

Round 2

使用Runner緩存加快前端構建過程
大家都知道npm_module被前端開發者詬病為毒瘤， 而Gitlab runner執行每次構建job之前都會清場，pull/fetch指定的代碼再執行job, 這就導致每次build job會耗時很久(要拉取毒瘤)。

#!/bin/bash

cd   packages/event-analysis
yarn config set registry http://registry.npm.gridsum.com &&  yarn --prefer-offline --frozen-lockfile
npm run build

以上是build任務的腳本frontend.sh，總耗時3m33s，其中yarn命令拉取npm_modules耗時172.52s

gitlab runner支持緩存
在.gitlab-ci.yaml 文件中定義cache指令:
cache被用來在job之間緩存文件，更強大的是可以定義文件依賴緩存：

build:
  stage: build
  cache:
    key:
      files:
        - packages/event-analysis/package.json
    paths:
      - node_modules
  script: 
    - ./frontend.sh
  tags:
    - my-tag

緩存key是yarn命令要用到的package.json，緩存內容是npm_modules;
只要這個package.json文件未變更，後續任務就會使用緩存的npm_modules，而不用重建npm_modules依賴。

使用runner緩存優化后build任務總耗時1m18s，其中yarn命令耗時22.83s:

以上針對Gitlab-CI的使用經驗點到為止，足夠應對我當前項目，更多請關注：

Reference

1. https://docs.gitlab.com/ee/ci/runners/#prevent-a-specific-runner-from-being-enabled-for-other-projects
2. https://docs.gitlab.com/ee/ci/caching/

Devops的圈子很大，上面的Gitlab-ci也只是點到為止，應付我當前的前後端分離項目.. 歡迎大家來捶我。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

※產品缺大量曝光嗎?你需要的是一流包裝設計!

目錄

• 簡介
• 功能依賴
• 生成RSA秘鑰
  • PKCS1格式
  • PKCS8格式
• 私鑰操作
  • PKCS1與PKCS8格式互轉
  • PKCS1與PKCS8私鑰中提取公鑰
• PEM操作
  • PEM格式密鑰讀取
  • PEM格式密鑰寫入
• RSA加解密
  • 獲取非對稱秘鑰參數（AsymmetricKeyParameter）
  • RSA加解與解密
  • RSA密文算法
• 編碼算法
  • BouncyCastle提供的Base64編碼算法
  • BouncyCastle提供的Hex十六進制編碼算法
• RSA加解密示例
• 下期預告

簡介

加解密現狀，編寫此項目的背景：

• 需要考慮系統環境兼容性問題（Linux、Windows）
• 語言互通問題（如C#、Java）
• 網上資料版本不一、不全面
• .NET官方庫密碼算法提供不全面，很難針對其他語言（Java）進行適配

本系列文章主要介紹如何結合BouncyCastle在 .NET Core 中使用非對稱加密算法、編碼算法、哈希算法、對稱加密算法、國密算法等一系列算法，內容篇幅代碼居多（加解密算法相關的原理知識網上有很多，因此不過多介紹）。如有錯誤之處，還請大家批評指正。

本系列代碼項目地址：https://github.com/fuluteam/ICH.BouncyCastle.git

功能依賴

BouncyCastle（https://www.bouncycastle.org/csharp） 是一個開放源碼的輕量級密碼術包；它支持大量的密碼術算法，它提供了很多.NET Core標準庫沒有的算法。

支持.NET 4，.NET Standard 1.0-2.0，WP，Silverlight，MonoAndroid，Xamarin.iOS，.NET Core

功能	依賴
Portable.BouncyCastle	Portable.BouncyCastle • 1.8.5

生成RSA秘鑰

PKCS1格式

/// <summary>
/// PKCS1（非Java適用）
/// </summary>
/// <param name="keySize">密鑰長度”一般只是指模值的位長度。目前主流可選值：1024、2048、3072、4096...</param>
/// <param name="format">PEM格式</param>
/// <returns></returns>
public RSAKeyParameter Pkcs1(int keySize, bool format=false)
{
    var keyGenerator = GeneratorUtilities.GetKeyPairGenerator("RSA");
    keyGenerator.Init(new KeyGenerationParameters(new SecureRandom(), keySize));

    var keyPair = keyGenerator.GenerateKeyPair();

    var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);
    var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
    
    if (!format)
    {
        return new RSAKeyParameter
        {
            PrivateKey = Base64.ToBase64String(privateKeyInfo.ParsePrivateKey().GetEncoded()),
            PublicKey = Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded())
        };
    }

    var rsaKey = new RSAKeyParameter();
    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(keyPair.Private);
        pWrt.Writer.Close();
        rsaKey.PrivateKey = sw.ToString();
    }

    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(keyPair.Public);
        pWrt.Writer.Close();
        rsaKey.PublicKey = sw.ToString();
    }

    return rsaKey;
}

PKCS8格式

/// <summary>
/// PKCS8（JAVA適用）
/// </summary>
/// <param name="keySize">密鑰長度”一般只是指模值的位長度。目前主流可選值：1024、2048、3072、4096...</param>
/// <param name="format">PEM格式</param>
/// <returns></returns>
public RSAKeyParameter Pkcs8(int keySize, bool format=false)
{
    var keyGenerator = GeneratorUtilities.GetKeyPairGenerator("RSA");
    keyGenerator.Init(new KeyGenerationParameters(new SecureRandom(), keySize));
    var keyPair = keyGenerator.GenerateKeyPair();

    var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);
    var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);

    if (!format)
    {
        return new RSAKeyParameter
        {
            PrivateKey = Base64.ToBase64String(privateKeyInfo.GetEncoded()),
            PublicKey = Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded())
        };
    }

    var rsaKey = new RSAKeyParameter();
    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        var pkcs8 = new Pkcs8Generator(keyPair.Private);
        pWrt.WriteObject(pkcs8);
        pWrt.Writer.Close();
        rsaKey.PrivateKey = sw.ToString();
    }

    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(keyPair.Public);
        pWrt.Writer.Close();
        rsaKey.PublicKey = sw.ToString();
    }

    return rsaKey;
}

私鑰操作

PKCS1與PKCS8格式互轉

僅私鑰有PKCS1和PKCS8之分，公鑰無格式區別。

 /// <summary>
 /// Pkcs1>>Pkcs8
 /// </summary>
 /// <param name="privateKey">Pkcs1私鑰</param>
 /// <param name="format">是否轉PEM格式</param>
 /// <returns></returns>
 public static string PrivateKeyPkcs1ToPkcs8(string privateKey, bool format = false)
 {
     var akp = RSAUtilities.GetAsymmetricKeyParameterFormPrivateKey(privateKey);
     if (format)
     {
         var sw = new StringWriter();
         var pWrt = new PemWriter(sw);
         var pkcs8 = new Pkcs8Generator(akp);
         pWrt.WriteObject(pkcs8);
         pWrt.Writer.Close();
         return sw.ToString();
     }
     else
     {
         var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(akp);
         return Base64.ToBase64String(privateKeyInfo.GetEncoded());
     }
 }

/// <summary>
/// Pkcs8>>Pkcs1
/// </summary>
/// <param name="privateKey">Pkcs8私鑰</param>
/// <param name="format">是否轉PEM格式</param>
/// <returns></returns>
public static string PrivateKeyPkcs8ToPkcs1(string privateKey, bool format = false)
{
    var akp = RSAUtilities.GetAsymmetricKeyParameterFormAsn1PrivateKey(privateKey);
    if (format)
    {
        var sw = new StringWriter();
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(akp);
        pWrt.Writer.Close();
        return sw.ToString();
    }
    else
    {
        var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(akp);
        return Base64.ToBase64String(privateKeyInfo.ParsePrivateKey().GetEncoded());
    }
}

PKCS1與PKCS8私鑰中提取公鑰

/// <summary>
/// 從Pkcs1私鑰中提取公鑰
/// </summary>
/// <param name="privateKey">Pkcs1私鑰</param>
/// <returns></returns>
public static string GetPublicKeyFromPrivateKeyPkcs1(string privateKey)
{
    var instance = RsaPrivateKeyStructure.GetInstance(Base64.Decode(privateKey));

    var publicParameter = (AsymmetricKeyParameter)new RsaKeyParameters(false, instance.Modulus,instance.PublicExponent);

    var privateParameter = (AsymmetricKeyParameter)new RsaPrivateCrtKeyParameters(instance.Modulus,instance.PublicExponent, instance.PrivateExponent, instance.Prime1, instance.Prime2, instance.Exponent1,instance.Exponent2, instance.Coefficient);

    var keyPair = new AsymmetricCipherKeyPair(publicParameter, privateParameter);
    var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);

    return Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded());
}

/// <summary>
/// 從Pkcs8私鑰中提取公鑰
/// </summary>
/// <param name="privateKey">Pkcs8私鑰</param>
/// <returns></returns>
public static string GetPublicKeyFromPrivateKeyPkcs8(string privateKey)
{
    var privateKeyInfo = PrivateKeyInfo.GetInstance(Asn1Object.FromByteArray(Base64.Decode(privateKey)));
    privateKey = Base64.ToBase64String(privateKeyInfo.ParsePrivateKey().GetEncoded());

    var instance = RsaPrivateKeyStructure.GetInstance(Base64.Decode(privateKey));

    var publicParameter = (AsymmetricKeyParameter)new RsaKeyParameters(false, instance.Modulus,instance.PublicExponent);

    var privateParameter = (AsymmetricKeyParameter)new RsaPrivateCrtKeyParameters(instance.Modulus,instance.PublicExponent, instance.PrivateExponent, instance.Prime1, instance.Prime2, instance.Exponent1,instance.Exponent2, instance.Coefficient);

    var keyPair = new AsymmetricCipherKeyPair(publicParameter, privateParameter);
    var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);

    return Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded());
}

PEM操作

PEM格式密鑰讀取

public static string ReadPkcs1PrivateKey(string text)
{
    if (!text.StartsWith("-----BEGIN RSA PRIVATE KEY-----"))
    {
        return text;
    }

    using (var reader = new StringReader(text))
    {
        var pr = new PemReader(reader);
        var keyPair = pr.ReadObject() as AsymmetricCipherKeyPair;
        pr.Reader.Close();

        var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair?.Private);
        return Base64.ToBase64String(privateKeyInfo.ParsePrivateKey().GetEncoded());
    }
}

public static string ReadPkcs8PrivateKey(string text)
{
    if (!text.StartsWith("-----BEGIN PRIVATE KEY-----"))
    {
        return text;
    }

    using (var reader = new StringReader(text))
    {
        var pr = new PemReader(reader);
        var akp = pr.ReadObject() as AsymmetricKeyParameter; ;
        pr.Reader.Close();
        return Base64.ToBase64String(PrivateKeyInfoFactory.CreatePrivateKeyInfo(akp).GetEncoded());
    }
}

 public static string ReadPublicKey(string text)
 {
    if (!text.StartsWith("-----BEGIN PUBLIC KEY-----"))
    {
        return text;
    }
    using (var reader = new StringReader(text))
    {
        var pr = new PemReader(reader);
        var keyPair = pr.ReadObject() as AsymmetricCipherKeyPair;
        pr.Reader.Close();

        var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair?.Public);
        returnBase64.ToBase64String(subjectPublicKeyIno.GetEncoded());
    }
 }

PEM格式密鑰寫入

public static string WritePkcs1PrivateKey(string privateKey)
{
    if (privateKey.StartsWith("-----BEGIN RSA PRIVATE KEY-----"))
    {
        return privateKey;
    }

    var akp = RSAUtilities.GetAsymmetricKeyParameterFormPrivateKey(privateKey);
    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(akp);
        pWrt.Writer.Close();
        return sw.ToString();
    }
}

public static string WritePkcs8PrivateKey(string privateKey)
{
    if (privateKey.StartsWith("-----BEGIN PRIVATE KEY-----"))
    {
        return privateKey;
    }

    var akp = RSAUtilities.GetAsymmetricKeyParameterFormAsn1PrivateKey(privateKey);

    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        var pkcs8 = new Pkcs8Generator(akp);
        pWrt.WriteObject(pkcs8);
        pWrt.Writer.Close();
        return sw.ToString();
    }
}

public static string WritePublicKey(string publicKey)
{
    if (publicKey.StartsWith("-----BEGIN PUBLIC KEY-----"))
    {
        return publicKey;
    }
    var akp = RSAUtilities.GetAsymmetricKeyParameterFormPublicKey(publicKey);
    using (var sw = new StringWriter())
    {
        var pWrt = new PemWriter(sw);
        pWrt.WriteObject(akp);
        pWrt.Writer.Close();
        return sw.ToString();
    }
}

RSA加解密

獲取非對稱秘鑰參數（AsymmetricKeyParameter）

/// <summary>
/// -----BEGIN RSA PRIVATE KEY-----
/// ...
/// -----END RSA PRIVATE KEY-----
/// </summary>
/// <param name="privateKey">Pkcs1格式私鑰</param>
/// <returns></returns>
public static AsymmetricKeyParameter GetAsymmetricKeyParameterFormPrivateKey(string privateKey)
{
    if (string.IsNullOrEmpty(privateKey))
    {
        throw new ArgumentNullException(nameof(privateKey));
    }

    var instance = RsaPrivateKeyStructure.GetInstance(Base64.Decode(privateKey));
    return new RsaPrivateCrtKeyParameters(instance.Modulus, instance.PublicExponent, instance.PrivateExponent,instance.Prime1, instance.Prime2, instance.Exponent1, instance.Exponent2, instance.Coefficient);
}

/// <summary>
/// -----BEGIN PRIVATE KEY-----
/// ...
/// -----END PRIVATE KEY-----
/// </summary>
/// <param name="privateKey">Pkcs8格式私鑰</param>
/// <returns></returns>
public static AsymmetricKeyParameter GetAsymmetricKeyParameterFormAsn1PrivateKey(string privateKey)
{
    return PrivateKeyFactory.CreateKey(Base64.Decode(privateKey));
}

/// <summary>
/// -----BEGIN PUBLIC KEY-----
/// ...
/// -----END PUBLIC KEY-----
/// </summary>
/// <param name="publicKey">公鑰</param>
/// <returns></returns>
public static AsymmetricKeyParameter GetAsymmetricKeyParameterFormPublicKey(string publicKey)
{
    if (string.IsNullOrEmpty(publicKey))
    {
        throw new ArgumentNullException(nameof(publicKey));
    }

    return PublicKeyFactory.CreateKey(Base64.Decode(publicKey));
}

RSA加解與解密

 /// <summary>
 /// RSA加密
 /// </summary>
 /// <param name="data">未加密數據字節數組</param>
 /// <param name="parameters">非對稱密鑰參數</param>
 /// <param name="algorithm">密文算法</param>
 /// <returns>已加密數據字節數組</returns>
 public static byte[] Encrypt(byte[] data, AsymmetricKeyParameter parameters, string algorithm)
 {
     if (data == null)
     {
         throw new ArgumentNullException(nameof(data));
     }
     if (parameters == null)
     {
         throw new ArgumentNullException(nameof(parameters));
     }
     if (string.IsNullOrEmpty(algorithm))
     {
         throw new ArgumentNullException(nameof(algorithm));
     }

     var bufferedCipher = CipherUtilities.GetCipher(algorithm);
     bufferedCipher.Init(true, parameters);
     return bufferedCipher.DoFinal(data);
 }

 /// <summary>
 /// RSA解密
 /// </summary>
 /// <param name="data">已加密數據字節數組</param>
 /// <param name="parameters">非對稱密鑰參數</param>
 /// <param name="algorithm">密文算法</param>
 /// <returns>未加密數據字節數組</returns>
 public static byte[] Decrypt(byte[] data, AsymmetricKeyParameter parameters, string algorithm)
{
    if (data == null)
    {
        throw new ArgumentNullException(nameof(data));
    }
    if (parameters == null)
    {
        throw new ArgumentNullException(nameof(parameters));
    }
    if (string.IsNullOrEmpty(algorithm))
    {
        throw new ArgumentNullException(nameof(algorithm));
    }
    var bufferedCipher = CipherUtilities.GetCipher(algorithm);
    bufferedCipher.Init(false, parameters);
    return bufferedCipher.DoFinal(data);
}

 /// <summary>
 /// RSA加密——Base64
 /// </summary>
 /// <param name="data">未加密字符串</param>
 /// <param name="parameters">非對稱密鑰參數</param>
 /// <param name="algorithm">密文算法</param>
 /// <returns>已加密Base64字符串</returns>
 public static string EncryptToBase64(string data, AsymmetricKeyParameter parameters, string algorithm)
 {
     return Base64.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(data), parameters, algorithm));
 }

 /// <summary>
 /// RSA解密——Base64
 /// </summary>
 /// <param name="data">已加密Base64字符串</param>
 /// <param name="parameters">非對稱密鑰參數</param>
 /// <param name="algorithm">密文算法</param>
 /// <returns>未加密字符串</returns>
 public static string DecryptFromBase64(string data, AsymmetricKeyParameter parameters, string algorithm)
 {
     return Encoding.UTF8.GetString(Decrypt(Base64.Decode(data), parameters, algorithm));
 }

/// <summary>
/// RSA加密——十六進制
/// </summary>
/// <param name="data">未加密字符串</param>
/// <param name="parameters">非對稱密鑰參數</param>
/// <param name="algorithm">密文算法</param>
/// <returns>已加密十六進制字符串</returns>
public static string EncryptToHex(string data, AsymmetricKeyParameter parameters, string algorithm)
{
    return Hex.ToHexString(Encrypt(Encoding.UTF8.GetBytes(data), parameters, algorithm));
}

///  <summary>
/// RSA解密——十六進制
/// </summary>
/// <param name="data">已加密十六進制字符串</param>
/// <param name="parameters">非對稱密鑰參數</param>
/// <param name="algorithm">密文算法</param>
/// <returns>未加密字符串</returns>
public static string DecryptFromHex(string data, AsymmetricKeyParameter parameters, string algorithm)
{
    return Encoding.UTF8.GetString(Decrypt(Hex.Decode(data), parameters, algorithm));
}

RSA密文算法

public const string RSA_NONE_NoPadding = "RSA/NONE/NoPadding";
public const string RSA_NONE_PKCS1Padding = "RSA/NONE/PKCS1Padding";
public const string RSA_NONE_OAEPPadding = "RSA/NONE/OAEPPadding";
public const string RSA_NONE_OAEPWithSHA1AndMGF1Padding = "RSA/NONE/OAEPWithSHA1AndMGF1Padding";
public const string RSA_NONE_OAEPWithSHA224AndMGF1Padding = "RSA/NONE/OAEPWithSHA224AndMGF1Padding";
public const string RSA_NONE_OAEPWithSHA256AndMGF1Padding = "RSA/NONE/OAEPWithSHA256AndMGF1Padding";
public const string RSA_NONE_OAEPWithSHA384AndMGF1Padding = "RSA/NONE/OAEPWithSHA384AndMGF1Padding";
public const string RSA_NONE_OAEPWithMD5AndMGF1Padding = "RSA/NONE/OAEPWithMD5AndMGF1Padding";

public const string RSA_ECB_NoPadding = "RSA/ECB/NoPadding";
public const string RSA_ECB_PKCS1Padding = "RSA/ECB/PKCS1Padding";
public const string RSA_ECB_OAEPPadding = "RSA/ECB/OAEPPadding";
public const string RSA_ECB_OAEPWithSHA1AndMGF1Padding = "RSA/ECB/OAEPWithSHA1AndMGF1Padding";
public const string RSA_ECB_OAEPWithSHA224AndMGF1Padding = "RSA/ECB/OAEPWithSHA224AndMGF1Padding";
public const string RSA_ECB_OAEPWithSHA256AndMGF1Padding = "RSA/ECB/OAEPWithSHA256AndMGF1Padding";
public const string RSA_ECB_OAEPWithSHA384AndMGF1Padding = "RSA/ECB/OAEPWithSHA384AndMGF1Padding";
public const string RSA_ECB_OAEPWithMD5AndMGF1Padding = "RSA/ECB/OAEPWithMD5AndMGF1Padding";

......

編碼算法

大家要明白，不管是對稱算法還是非對稱算法，其輸入與輸出均是字節數組，通常我們要結合編碼算法對加密之後或解密之前的數據，進行編碼操作。

BouncyCastle提供的Base64編碼算法

namespace Org.BouncyCastle.Utilities.Encoders
{
    public sealed class Base64
    {
        //
        public static byte[] Decode(byte[] data);
        //
        public static byte[] Decode(string data);
        //
        public static int Decode(string data, Stream outStream);
        //
        public static byte[] Encode(byte[] data);
        //
        public static byte[] Encode(byte[] data, int off, int length);
        //
        public static int Encode(byte[] data, Stream outStream);
        //
        public static int Encode(byte[] data, int off, int length, Stream outStream);
        public static string ToBase64String(byte[] data);
        public static string ToBase64String(byte[] data, int off, int length);
    }
}

BouncyCastle提供的Hex十六進制編碼算法

namespace Org.BouncyCastle.Utilities.Encoders
{
    //
    // 摘要:
    //     Class to decode and encode Hex.
    public sealed class Hex
    {
        //
        public static byte[] Decode(byte[] data);
        //
        public static byte[] Decode(string data);
        //
        public static int Decode(string data, Stream outStream);
        //
        public static byte[] Encode(byte[] data);
        //
        public static byte[] Encode(byte[] data, int off, int length);
        //
        public static int Encode(byte[] data, Stream outStream);
        //
        public static int Encode(byte[] data, int off, int length, Stream outStream);
        public static string ToHexString(byte[] data);
        public static string ToHexString(byte[] data, int off, int length);
    }
}

RSA加解密示例

private static void RSA_ECB_PKCS1Padding()
 {
     var data = "hello rsa";

     Console.WriteLine($"加密原文：{data}");

     // rsa pkcs8 private key encrypt
     //algorithm  rsa/ecb/pkcs1padding
     var pkcs8data = RSA.EncryptToBase64(data, RSAUtilities.GetAsymmetricKeyParameterFormAsn1PrivateKey(pkcs8_1024_private_key),CipherAlgorithms.RSA_ECB_PKCS1Padding);

     Console.WriteLine("密鑰格式：pkcs8，密文算法：rsa/ecb/pkcs1padding，加密結果");
     Console.WriteLine(pkcs8data);

     //rsa pkcs1 private key encrypt
     //algorithm  rsa/ecb/pkcs1padding
     var pkcs1data = RSA.EncryptToBase64(data, RSAUtilities.GetAsymmetricKeyParameterFormPrivateKey(pkcs1_1024_private_key),CipherAlgorithms.RSA_ECB_PKCS1Padding);

     Console.WriteLine($"密鑰格式：pkcs1，密文算法：rsa/ecb/pkcs1padding");
     Console.WriteLine(pkcs1data);

     Console.WriteLine($"加密結果比對是否一致：{pkcs8data.Equals(pkcs1data)}");

     var _1024_public_key = RSAKeyConverter.GetPublicKeyFromPrivateKeyPkcs1(pkcs1_1024_private_key);

     Console.WriteLine($"從pkcs1私鑰中提取公鑰：");
     Console.WriteLine(_1024_public_key);

     Console.WriteLine("使用公鑰解密數據：");
     //rsa public key decrypt
     //algorithm  rsa/ecb/pkcs1padding
     Console.WriteLine(RSA.DecryptFromBase64(pkcs1data, RSAUtilities.GetAsymmetricKeyParameterFormPublicKey(_1024_public_key),CipherAlgorithms.RSA_ECB_PKCS1Padding));

     Console.WriteLine();
 }

下期預告

下一篇將介紹哈希算法（HMACSHA1、HMACSHA256、SHA1、SHA1WithRSA、SHA256、SHA256WithRSA），敬請期待…

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

kubeadm介紹

kubeadm概述

參考附003.Kubeadm部署Kubernetes。

kubeadm功能

參考附003.Kubeadm部署Kubernetes。

本方案描述

• 本方案採用kubeadm部署Kubernetes 1.18.3版本；
• etcd採用混部方式；
• Keepalived：實現VIP高可用；
• Nginx：以Pod形式運行與Kubernetes之上，即in Kubernetes模式，提供反向代理至3個master 6443端口；
• 其他主要部署組件包括：
  • Metrics：度量；
  • Dashboard：Kubernetes 圖形UI界面；
  • Helm：Kubernetes Helm包管理工具；
  • Ingress：Kubernetes 服務暴露；
  • Longhorn：Kubernetes 動態存儲組件。

部署規劃

節點規劃

節點主機名	IP	類型	運行服務
master01	172.24.8.71	Kubernetes master節點	docker、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、kubectl、kubelet、metrics、calico
master02	172.24.8.72	Kubernetes master節點	docker、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、kubectl、kubelet、metrics、calico
master03	172.24.8.73	Kubernetes master節點	docker、etcd、kube-apiserver、kube-scheduler、kube-controller-manager、kubectl、kubelet、metrics、calico
worker01	172.24.8.74	Kubernetes worker節點	docker、kubelet、proxy、calico
worker02	172.24.8.75	Kubernetes worker節點	docker、kubelet、proxy、calico
worker03	172.24.8.76	Kubernetes worker節點	docker、kubelet、proxy、calico

Kubernetes的高可用主要指的是控制平面的高可用，即指多套Master節點組件和Etcd組件，工作節點通過負載均衡連接到各Master。

Kubernetes高可用架構中etcd與Master節點組件混布方式特點：

• Etcd混布方式
• 所需機器資源少
• 部署簡單，利於管理
• 容易進行橫向擴展
• 風險大，一台宿主機掛了，master和etcd就都少了一套，集群冗餘度受到的影響比較大。

提示：本實驗使用Keepalived+Nginx架構實現Kubernetes的高可用。

初始準備

[root@master01 ~]# hostnamectl set-hostname master01 #其他節點依次修改

[root@master01 ~]# cat >> /etc/hosts << EOF
172.24.8.71 master01··
172.24.8.72 master02
172.24.8.73 master03
172.24.8.74 worker01
172.24.8.75 worker02
172.24.8.76 worker03
EOF

[root@master01 ~]# vi k8sinit.sh

#!/bin/sh
#****************************************************************#
# ScriptName: k8sinit.sh
# Author: xhy
# Create Date: 2020-05-30 16:30
# Modify Author: xhy
# Modify Date: 2020-05-30 16:30
# Version: 
#***************************************************************#
# Initialize the machine. This needs to be executed on every machine.

# Add docker user
useradd -m docker

# Disable the SELinux.
sed -i 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config

# Turn off and disable the firewalld.
systemctl stop firewalld
systemctl disable firewalld

# Modify related kernel parameters & Disable the swap.
cat > /etc/sysctl.d/k8s.conf << EOF
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.tcp_tw_recycle = 0
vm.swappiness = 0
vm.overcommit_memory = 1
vm.panic_on_oom = 0
net.ipv6.conf.all.disable_ipv6 = 1
EOF
sysctl -p /etc/sysctl.d/k8s.conf >&/dev/null
swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
modprobe br_netfilter

# Add ipvs modules
cat > /etc/sysconfig/modules/ipvs.modules <<EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
modprobe -- nf_conntrack
EOF

chmod 755 /etc/sysconfig/modules/ipvs.modules
bash /etc/sysconfig/modules/ipvs.modules

# Install rpm
yum install -y conntrack ntpdate ntp ipvsadm ipset jq iptables curl sysstat libseccomp wget

# Install Docker Compose
sudo curl -L "http://down.linuxsb.com:8888/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Update kernel
rpm --import http://down.linuxsb.com:8888/RPM-GPG-KEY-elrepo.org
rpm -Uvh http://down.linuxsb.com:8888/elrepo-release-7.0-4.el7.elrepo.noarch.rpm
yum --disablerepo="*" --enablerepo="elrepo-kernel" install -y kernel-ml
sed -i 's/^GRUB_DEFAULT=.*/GRUB_DEFAULT=0/' /etc/default/grub
grub2-mkconfig -o /boot/grub2/grub.cfg
yum update -y

# Reboot the machine.
# reboot

提示：對於某些特性，可能需要升級內核，內核升級操作見《018.Linux升級內核》。4.19版及以上內核nf_conntrack_ipv4已經改為nf_conntrack。

互信配置

為了更方便遠程分發文件和執行命令，本實驗配置master節點到其它節點的 ssh 信任關係。

[root@master01 ~]# ssh-keygen -f ~/.ssh/id_rsa -N ''
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@master01
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@master02
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@master03
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@worker01
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@worker02
[root@master01 ~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@worker03

提示：此操作僅需要在master節點操作。

其他準備

[root@master01 ~]# vi environment.sh

#!/bin/sh
#****************************************************************#
# ScriptName: environment.sh
# Author: xhy
# Create Date: 2020-05-30 16:30
# Modify Author: xhy
# Modify Date: 2020-05-30 16:30
# Version: 
#***************************************************************#
# 集群 MASTER 機器 IP 數組
export MASTER_IPS=(172.24.8.71 172.24.8.72 172.24.8.73)

# 集群 MASTER IP 對應的主機名數組
export MASTER_NAMES=(master01 master02 master03)

# 集群 NODE 機器 IP 數組
export NODE_IPS=(172.24.8.74 172.24.8.75 172.24.8.76)

# 集群 NODE IP 對應的主機名數組
export NODE_NAMES=(worker01 worker02 worker03)

# 集群所有機器 IP 數組
export ALL_IPS=(172.24.8.71 172.24.8.72 172.24.8.73 172.24.8.74 172.24.8.75 172.24.8.76)

# 集群所有IP 對應的主機名數組
export ALL_NAMES=(master01 master02 master03 worker01 worker02 worker03)

[root@master01 ~]# source environment.sh
[root@master01 ~]# chmod +x *.sh
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    scp -rp /etc/hosts root@${all_ip}:/etc/hosts
    scp -rp k8sinit.sh root@${all_ip}:/root/
    ssh root@${all_ip} "bash /root/k8sinit.sh"
  done

集群部署

Docker安裝

[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "yum -y install yum-utils device-mapper-persistent-data lvm2"
    ssh root@${all_ip} "yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo"
    ssh root@${all_ip} "yum -y install docker-ce"
    ssh root@${all_ip} "mkdir /etc/docker"
    ssh root@${all_ip} "cat > /etc/docker/daemon.json <<EOF
{
  \"registry-mirrors\": [\"https://dbzucv6w.mirror.aliyuncs.com\"],
  \"exec-opts\": [\"native.cgroupdriver=systemd\"],
  \"log-driver\": \"json-file\",
  \"log-opts\": {
    \"max-size\": \"100m\"
  },
  \"storage-driver\": \"overlay2\",
  \"storage-opts\": [
    \"overlay2.override_kernel_check=true\"
  ]
}
EOF"
    ssh root@${all_ip} "systemctl restart docker"
    ssh root@${all_ip} "systemctl enable docker"
    ssh root@${all_ip} "systemctl status docker"
    ssh root@${all_ip} "iptables -nvL"
  done

提示：如上僅需Master01節點操作，從而實現所有節點自動化安裝。

相關組件包

需要在每台機器上都安裝以下的軟件包：

• kubeadm: 用來初始化集群的指令；
• kubelet: 在集群中的每個節點上用來啟動 pod 和 container 等；
• kubectl: 用來與集群通信的命令行工具。

kubeadm不能安裝或管理 kubelet 或 kubectl ，所以得保證他們滿足通過 kubeadm 安裝的 Kubernetes控制層對版本的要求。如果版本沒有滿足要求，可能導致一些意外錯誤或問題。
具體相關組件安裝見；附001.kubectl介紹及使用書

提示：Kubernetes 1.18版本所有兼容相應組件的版本參考：https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.18.md。

正式安裝

[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF"
    ssh root@${all_ip} "yum install -y kubeadm-1.18.3-0.x86_64 kubelet-1.18.3-0.x86_64 kubectl-1.18.3-0.x86_64 --disableexcludes=kubernetes"
    ssh root@${all_ip} "systemctl enable kubelet"
done

[root@master01 ~]# yum search -y kubelet --showduplicates #查看相應版本

提示：如上僅需Master01節點操作，從而實現所有節點自動化安裝，同時此時不需要啟動kubelet，初始化的過程中會自動啟動的，如果此時啟動了會出現報錯，忽略即可。

說明：同時安裝了cri-tools, kubernetes-cni, socat三個依賴： socat：kubelet的依賴； cri-tools：即CRI(Container Runtime Interface)容器運行時接口的命令行工具。

部署高可用組件I

Keepalived安裝

[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "yum -y install gcc gcc-c++ make libnl libnl-devel libnfnetlink-devel openssl-devel"
    ssh root@${master_ip} "wget http://down.linuxsb.com:8888/software/keepalived-2.0.20.tar.gz"
    ssh root@${master_ip} "tar -zxvf keepalived-2.0.20.tar.gz"
    ssh root@${master_ip} "cd keepalived-2.0.20/ && ./configure --sysconf=/etc --prefix=/usr/local/keepalived && make && make install"
    ssh root@${master_ip} "systemctl enable keepalived && systemctl start keepalived"
  done

提示：如上僅需Master01節點操作，從而實現所有節點自動化安裝。

創建配置文件

[root@master01 ~]# wget http://down.linuxsb.com:8888/ngkek8s.sh		#拉取自動部署腳本
[root@master01 ~]# chmod u+x ngkek8s.sh

[root@master01 ~]# vi ngkek8s.sh
#!/bin/sh
#****************************************************************#
# ScriptName: k8s_ha.sh
# Author: xhy
# Create Date: 2020-05-13 16:32
# Modify Author: xhy
# Modify Date: 2020-06-12 12:53
# Version: v2
#***************************************************************#

#######################################
# set variables below to create the config files, all files will create at ./config directory
#######################################

# master keepalived virtual ip address
export K8SHA_VIP=172.24.8.100

# master01 ip address
export K8SHA_IP1=172.24.8.71

# master02 ip address
export K8SHA_IP2=172.24.8.72

# master03 ip address
export K8SHA_IP3=172.24.8.73

# master01 hostname
export K8SHA_HOST1=master01

# master02 hostname
export K8SHA_HOST2=master02

# master03 hostname
export K8SHA_HOST3=master03

# master01 network interface name
export K8SHA_NETINF1=eth0

# master02 network interface name
export K8SHA_NETINF2=eth0

# master03 network interface name
export K8SHA_NETINF3=eth0

# keepalived auth_pass config
export K8SHA_KEEPALIVED_AUTH=412f7dc3bfed32194d1600c483e10ad1d

# kubernetes CIDR pod subnet
export K8SHA_PODCIDR=10.10.0.0

# kubernetes CIDR svc subnet
export K8SHA_SVCCIDR=10.20.0.0

[root@master01 ~]# ./ngkek8s.sh

解釋：如上僅需Master01節點操作。執行ngkek8s.sh腳本后，會自動生成以下配置文件：

• kubeadm-config.yaml：kubeadm初始化配置文件，位於當前目錄
• keepalived：keepalived配置文件，位於各個master節點的/etc/keepalived目錄
• nginx-lb：nginx-lb負載均衡配置文件，位於各個master節點的/etc/kubernetes/nginx-lb/目錄
• calico.yaml：calico網絡組件部署文件，位於config/calico/目錄

[root@master01 ~]# cat kubeadm-config.yaml		#檢查集群初始化配置
apiVersion: kubeadm.k8s.io/v1beta2
kind: ClusterConfiguration
networking:
  serviceSubnet: "10.20.0.0/16"			     	#設置svc網段
  podSubnet: "10.10.0.0/16"			        #設置Pod網段
  dnsDomain: "cluster.local"
kubernetesVersion: "v1.18.3"			    	#設置安裝版本
controlPlaneEndpoint: "172.24.8.100:16443"		#設置相關API VIP地址
apiServer:
  certSANs:
  - master01
  - master02
  - master03
  - 127.0.0.1
  - 172.24.8.71
  - 172.24.8.72
  - 172.24.8.73
  - 172.24.8.100
  timeoutForControlPlane: 4m0s
certificatesDir: "/etc/kubernetes/pki"
imageRepository: "k8s.gcr.io"
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
featureGates:
  SupportIPVSProxyMode: true
mode: ipvs

提示：如上僅需Master01節點操作，更多config文件參考：https://godoc.org/k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2。
此kubeadm部署初始化配置更多參考：https://pkg.go.dev/k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2?tab=doc。

啟動Keepalived

[root@master01 ~]# cat /etc/keepalived/check_apiserver.sh	#確認Keepalived配置

[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "systemctl start keepalived.service && systemctl enable keepalived.service"
    ssh root@${master_ip} "systemctl status keepalived.service | grep Active"
  done

[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "ping -c1 172.24.8.100"
  done								#等待10s左右執行檢查

提示：如上僅需Master01節點操作，從而實現所有節點自動啟動服務。

啟動Nginx

執行ngkek8s.sh腳本后，nginx-lb的配置文件會自動複製到各個master的節點的/etc/kubernetes/nginx-lb目錄。

[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "cd /etc/kubernetes/nginx-lb/ && docker-compose up -d"
    ssh root@${master_ip} "docker-compose ps"
  done

提示：如上僅需Master01節點操作，從而實現所有節點自動啟動服務。

初始化集群-Master

拉取鏡像

[root@master01 ~]# kubeadm --kubernetes-version=v1.18.3 config images list #列出所需鏡像

[root@master01 ~]# cat config/downimage.sh			#確認版本，提前下載鏡像
#!/bin/sh
#****************************************************************#
# ScriptName: downimage.sh
# Author: xhy
# Create Date: 2020-05-29 19:55
# Modify Author: xhy
# Modify Date: 2020-05-30 16:07
# Version: v2
#***************************************************************#

KUBE_VERSION=v1.18.3
CALICO_VERSION=v3.14.1
CALICO_URL=calico
KUBE_PAUSE_VERSION=3.2
ETCD_VERSION=3.4.3-0
CORE_DNS_VERSION=1.6.7
GCR_URL=k8s.gcr.io
METRICS_SERVER_VERSION=v0.3.6
INGRESS_VERSION=0.32.0
CSI_PROVISIONER_VERSION=v1.4.0
CSI_NODE_DRIVER_VERSION=v1.2.0
CSI_ATTACHER_VERSION=v2.0.0
CSI_RESIZER_VERSION=v0.3.0 
ALIYUN_URL=registry.cn-hangzhou.aliyuncs.com/google_containers
UCLOUD_URL=uhub.service.ucloud.cn/uxhy
QUAY_URL=quay.io

kubeimages=(kube-proxy:${KUBE_VERSION}
kube-scheduler:${KUBE_VERSION}
kube-controller-manager:${KUBE_VERSION}
kube-apiserver:${KUBE_VERSION}
pause:${KUBE_PAUSE_VERSION}
etcd:${ETCD_VERSION}
coredns:${CORE_DNS_VERSION}
metrics-server-amd64:${METRICS_SERVER_VERSION}
)

for kubeimageName in ${kubeimages[@]} ; do
docker pull $UCLOUD_URL/$kubeimageName
docker tag $UCLOUD_URL/$kubeimageName $GCR_URL/$kubeimageName
docker rmi $UCLOUD_URL/$kubeimageName
done

calimages=(cni:${CALICO_VERSION}
pod2daemon-flexvol:${CALICO_VERSION}
node:${CALICO_VERSION}
kube-controllers:${CALICO_VERSION})

for calimageName in ${calimages[@]} ; do
docker pull $UCLOUD_URL/$calimageName
docker tag $UCLOUD_URL/$calimageName $CALICO_URL/$calimageName
docker rmi $UCLOUD_URL/$calimageName
done

ingressimages=(nginx-ingress-controller:${INGRESS_VERSION})

for ingressimageName in ${ingressimages[@]} ; do
docker pull $UCLOUD_URL/$ingressimageName
docker tag $UCLOUD_URL/$ingressimageName $QUAY_URL/kubernetes-ingress-controller/$ingressimageName
docker rmi $UCLOUD_URL/$ingressimageName
done

csiimages=(csi-provisioner:${CSI_PROVISIONER_VERSION}
csi-node-driver-registrar:${CSI_NODE_DRIVER_VERSION}
csi-attacher:${CSI_ATTACHER_VERSION}
csi-resizer:${CSI_RESIZER_VERSION}
)

for csiimageName in ${csiimages[@]} ; do
docker pull $UCLOUD_URL/$csiimageName
docker tag $UCLOUD_URL/$csiimageName $QUAY_URL/k8scsi/$csiimageName
docker rmi $UCLOUD_URL/$csiimageName
done

[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    scp -rp config/downimage.sh root@${all_ip}:/root/
    ssh root@${all_ip} "bash downimage.sh &"
  done

提示：如上僅需Master01節點操作，從而實現所有節點自動拉取鏡像。
[root@master01 ~]# docker images #確認驗證

Master上初始化

[root@master01 ~]# kubeadm init --config=kubeadm-config.yaml --upload-certs  

保留如下命令用於後續節點添加：
You can now join any number of the control-plane node running the following command on each as root:

  kubeadm join 172.24.8.100:16443 --token xb9wda.v0yf7tlsgo8mdrhk \
    --discovery-token-ca-cert-hash sha256:249884d81a23bd821e38d3345866a99e6d55e443b545825c3c448f30f8e52c3b \
    --control-plane --certificate-key e30428776a47ed2c7e18c9e2951d9e40e068c9ecec5a4858457f1475f1a2a39a

Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 172.24.8.100:16443 --token xb9wda.v0yf7tlsgo8mdrhk \
    --discovery-token-ca-cert-hash sha256:249884d81a23bd821e38d3345866a99e6d55e443b545825c3c448f30f8e52c3b

注意：如上token具有默認24小時的有效期，token和hash值可通過如下方式獲取： kubeadm token list 如果 Token 過期以後，可以輸入以下命令，生成新的 Token:

kubeadm token create
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'***

[root@master01 ~]# mkdir -p $HOME/.kube [root@master01 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config [root@master01 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

[root@master01 ~]# cat << EOF >> ~/.bashrc
export KUBECONFIG=$HOME/.kube/config
EOF							#設置KUBECONFIG環境變量

[root@master01 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[root@master01 ~]# source ~/.bashrc

附加：初始化過程大致步驟如下：

1. [kubelet-start] 生成kubelet的配置文件”/var/lib/kubelet/config.yaml”
2. [certificates]生成相關的各種證書
3. [kubeconfig]生成相關的kubeconfig文件
4. [bootstraptoken]生成token記錄下來，後邊使用kubeadm join往集群中添加節點時會用到

提示：初始化僅需要在master01上執行，若初始化異常可通過kubeadm reset && rm -rf $HOME/.kube重置。

添加其他master節點

[root@master02 ~]# kubeadm join 172.24.8.100:16443 --token xb9wda.v0yf7tlsgo8mdrhk \
    --discovery-token-ca-cert-hash sha256:249884d81a23bd821e38d3345866a99e6d55e443b545825c3c448f30f8e52c3b \
    --control-plane --certificate-key e30428776a47ed2c7e18c9e2951d9e40e068c9ecec5a4858457f1475f1a2a39a

[root@master02 ~]# mkdir -p $HOME/.kube
[root@master02 ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@master02 ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config
 [root@master02 ~]# cat << EOF >> ~/.bashrc`
export KUBECONFIG=$HOME/.kube/config
EOF						               	#設置KUBECONFIG環境變量
[root@master02 ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[root@master02 ~]# source ~/.bashrc

提示：master03也如上執行添加至集群的controlplane。
提示：若添加異常可通過kubeadm reset && rm -rf $HOME/.kube重置。

安裝NIC插件

NIC插件介紹

• Calico 是一個安全的 L3 網絡和網絡策略提供者。
• Canal 結合 Flannel 和 Calico， 提供網絡和網絡策略。
• Cilium 是一個 L3 網絡和網絡策略插件， 能夠透明的實施 HTTP/API/L7 策略。 同時支持路由（routing）和疊加/封裝（ overlay/encapsulation）模式。
• Contiv 為多種用例提供可配置網絡（使用 BGP 的原生 L3，使用 vxlan 的 overlay，經典 L2 和 Cisco-SDN/ACI）和豐富的策略框架。Contiv 項目完全開源。安裝工具同時提供基於和不基於 kubeadm 的安裝選項。
• Flannel 是一個可以用於 Kubernetes 的 overlay 網絡提供者。 +Romana 是一個 pod 網絡的層 3 解決方案，並且支持 NetworkPolicy API。Kubeadm add-on 安裝細節可以在這裏找到。
• Weave Net 提供了在網絡分組兩端參与工作的網絡和網絡策略，並且不需要額外的數據庫。
• CNI-Genie 使 Kubernetes 無縫連接到一種 CNI 插件，例如：Flannel、Calico、Canal、Romana 或者 Weave。
  提示：本方案使用Calico插件。

設置標籤

[root@master01 ~]# kubectl taint nodes --all node-role.kubernetes.io/master- #允許master部署應用

提示：部署完內部應用后可使用kubectl taint node master01 node-role.kubernetes.io/master=””:NoSchedule重新設置Master為Master Only 狀態。

部署calico

[root@master01 ~]# cat config/calico/calico.yaml	#檢查配置
……
            - name: CALICO_IPV4POOL_CIDR
              value: "10.10.0.0/16"		        #檢查Pod網段
……
            - name: IP_AUTODETECTION_METHOD
              value: "interface=eth.*"		     	#檢查節點之間的網卡
# Auto-detect the BGP IP address.
            - name: IP
              value: "autodetect"
……

[root@master01 ~]# kubectl apply -f config/calico/calico.yaml
[root@master01 ~]# kubectl get pods --all-namespaces -o wide		#查看部署
[root@master01 ~]# kubectl get nodes

修改node端口範圍

[root@master01 ~]# vi /etc/kubernetes/manifests/kube-apiserver.yaml
……
    - --service-node-port-range=1-65535
……

部署高可用組件II

高可用說明

高可用kubernetes集群步驟三已完成配置，但是使用docker-compose方式啟動nginx-lb由於無法提供kubernetes集群的健康檢查和自動重啟功能，nginx-lb作為高可用kubernetes集群的核心組件建議也作為kubernetes集群中的一個pod來進行管理。

污點和標籤

[root@master01 ~]# kubectl taint node master01 node-`role.kubernetes.io/master="":NoSchedule
[root@master01 ~]# kubectl taint node master02 node-role.kubernetes.io/master="":NoSchedule
[root@master01 ~]# kubectl taint node master03 node-role.kubernetes.io/master="":NoSchedule
[root@master01 ~]# kubectl label nodes master01 node-role.kubernetes.io/master="true" --overwrite
[root@master01 ~]# kubectl label nodes master02 node-role.kubernetes.io/master="true" --overwrite
[root@master01 ~]# kubectl label nodes master02 node-role.kubernetes.io/master="true" --overwrite

容器化實現高可用

[root@master01 ~]# for master_ip in ${MASTER_IPS[@]}
  do
    echo ">>> ${master_ip}"
    ssh root@${master_ip} "systemctl stop kubelet"
    ssh root@${master_ip} "docker stop nginx-lb && docker rm nginx-lb"
    scp -rp /root/config/k8s-nginx-lb.yaml root@${master_ip}:/etc/kubernetes/manifests/
    ssh root@${master_ip} "systemctl restart kubelet docker"
  done

提示：如上僅需Master01節點操作，從而實現所有Master節點自動啟動服務。

[root@master01 ~]# kubectl -n kube-system get pods -o wide | grep -E 'NAME|nginx'

添加Worker節點

添加Worker節點

[root@master01 ~]# source environment.sh

[root@master01 ~]# for node_ip in ${NODE_IPS[@]}
  do
    echo ">>> ${node_ip}"
    ssh root@${node_ip} "kubeadm join 172.24.8.100:16443 --token xb9wda.v0yf7tlsgo8mdrhk \
    --discovery-token-ca-cert-hash sha256:249884d81a23bd821e38d3345866a99e6d55e443b545825c3c448f30f8e52c3b"
    ssh root@${node_ip} "systemctl enable kubelet.service"
  done

提示：如上僅需Master01節點操作，從而實現所有Worker節點添加至集群，若添加異常可通過如下方式重置：

[root@node01 ~]# kubeadm reset
[root@node01 ~]# ifconfig cni0 down
[root@node01 ~]# ip link delete cni0
[root@node01 ~]# ifconfig flannel.1 down
[root@node01 ~]# ip link delete flannel.1
[root@node01 ~]# rm -rf /var/lib/cni/

確認驗證

[root@master01 ~]# kubectl get nodes			         	#節點狀態
[root@master01 ~]# kubectl get cs			             	#組件狀態
[root@master01 ~]# kubectl get serviceaccount		     	        #服務賬戶
[root@master01 ~]# kubectl cluster-info			         	#集群信息
[root@master01 ~]# kubectl get pod -n kube-system -o wide	        #所有服務狀態

提示：更多Kubetcl使用參考：https://kubernetes.io/docs/reference/kubectl/kubectl/ https://kubernetes.io/docs/reference/kubectl/overview/
更多kubeadm使用參考：https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/

Metrics部署

Metrics

Kubernetes的早期版本依靠Heapster來實現完整的性能數據採集和監控功能，Kubernetes從1.8版本開始，性能數據開始以Metrics API的方式提供標準化接口，並且從1.10版本開始將Heapster替換為Metrics Server。在Kubernetes新的監控體系中，Metrics Server用於提供核心指標（Core Metrics），包括Node、Pod的CPU和內存使用指標。 對其他自定義指標（Custom Metrics）的監控則由Prometheus等組件來完成。

開啟聚合層

有關聚合層知識參考：https://blog.csdn.net/liukuan73/article/details/81352637 kubeadm方式部署默認已開啟。

獲取部署文件

[root@master01 ~]# mkdir metrics
[root@master01 ~]# cd metrics/
[root@master01 metrics]# wget https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.3.6/components.yaml

[root@master01 metrics]# vi components.yaml
……
apiVersion: apps/v1
kind: Deployment
……
spec:
  replicas: 3						        	#根據集群規模調整副本數
……
    spec:
      hostNetwork: true
……
      - name: metrics-server
        image: k8s.gcr.io/metrics-server-amd64:v0.3.6
        imagePullPolicy: IfNotPresent
        args:
          - --cert-dir=/tmp
          - --secure-port=4443
          - --kubelet-insecure-tls				        #追加此args
          - --kubelet-preferred-address-types=InternalIP,Hostname,InternalDNS,ExternalDNS,ExternalIP	#追加此args
……

正式部署

[root@master01 metrics]# kubectl apply -f components.yaml
[root@master01 metrics]# kubectl -n kube-system get pods -l k8s-app=metrics-server
NAME                              READY   STATUS    RESTARTS   AGE
metrics-server-7b97647899-ghnxw   1/1     Running   0          11s
metrics-server-7b97647899-nqwvq   1/1     Running   0          10s
metrics-server-7b97647899-zkmxs   1/1     Running   0          10s

查看資源監控

[root@k8smaster01 ~]# kubectl top nodes
[root@k8smaster01 ~]# kubectl top pods --all-namespaces

提示：Metrics Server提供的數據也可以供HPA控制器使用，以實現基於CPU使用率或內存使用值的Pod自動擴縮容功能。
部署參考：https://linux48.com/container/2019-11-13-metrics-server.html 有關metrics更多部署參考： https://kubernetes.io/docs/tasks/debug-application-cluster/resource-metrics-pipeline/
開啟開啟API Aggregation參考： https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/
API Aggregation介紹參考： https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/

Nginx ingress部署

參考附020.Nginx-ingress部署及使用，建議採用社區版。

Dashboard部署

設置標籤

[root@master01 ~]# kubectl label nodes master01 dashboard=yes
[root@master01 ~]# kubectl label nodes master02 dashboard=yes
[root@master01 ~]# kubectl label nodes master03 dashboard=yes

創建證書

本實驗已獲取免費一年的證書，免費證書獲取可參考：https://freessl.cn。

[root@master01 ~]# mkdir -p /root/dashboard/certs
[root@master01 ~]# cd /root/dashboard/certs
[root@master01 certs]# mv k8s.odocker.com tls.crt
[root@master01 certs]# mv k8s.odocker.com tls.crt
[root@master01 certs]# ll
total 8.0K
-rw-r--r-- 1 root root 1.9K Jun  8 11:46 tls.crt
-rw-r--r-- 1 root root 1.7K Jun  8 11:46 tls.ke

提示：也可手動如下操作創建自簽證書：

[root@master01 ~]# openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt -subj "/C=CN/ST=ZheJiang/L=HangZhou/O=Xianghy/OU=Xianghy/CN=k8s.odocker.com"

手動創建secret

[root@master01 ~]# kubectl create ns kubernetes-dashboard	#v2版本dashboard獨立ns
[root@master01 ~]# kubectl create secret generic kubernetes-dashboard-certs --from-file=$HOME/dashboard/certs/ -n kubernetes-dashboard
[root@master01 ~]# kubectl get secret kubernetes-dashboard-certs -n kubernetes-dashboard -o yaml		#查看新證書`

下載yaml

[root@master01 ~]# cd /root/dashboard
[root@master01 dashboard]# wget https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.1/aio/deploy/recommended.yaml

修改yaml

[root@master01 dashboard]# vi recommended.yaml
……
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  type: NodePort			       	#新增
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30001				#新增
  selector:
    k8s-app: kubernetes-dashboard
---
……						#如下全部註釋
#apiVersion: v1
#kind: Secret
#metadata:
#  labels:
#    k8s-app: kubernetes-dashboard
#  name: kubernetes-dashboard-certs
#  namespace: kubernetes-dashboard
#type: Opaque
……
kind: Deployment
……
  replicas: 3					        #適當調整為3副本
……
          imagePullPolicy: IfNotPresent		        #修改鏡像下載策略
          ports:
            - containerPort: 8443
              protocol: TCP
          args:
            - --auto-generate-certificates
            - --namespace=kubernetes-dashboard
            - --tls-key-file=tls.key
            - --tls-cert-file=tls.crt
            - --token-ttl=3600	       		        #追加如上args
……
      nodeSelector:
        "beta.kubernetes.io/os": linux
        "dashboard": "yes"	        		#部署在master節點
……
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: dashboard-metrics-scraper
  name: dashboard-metrics-scraper
  namespace: kubernetes-dashboard
spec:
  type: NodePort	             			#新增
  ports:
    - port: 8000
      nodePort: 30000		         		#新增
      targetPort: 8000
  selector:                                                                                  
    k8s-app: dashboard-metrics-scraper
……
   replicas: 3			            		#適當調整為3副本
……
      nodeSelector:
        "beta.kubernetes.io/os": linux
        "dashboard": "yes"	        		#部署在master節點
……

正式部署

[root@master01 dashboard]# kubectl apply -f recommended.yaml
[root@master01 dashboard]# kubectl get deployment kubernetes-dashboard -n kubernetes-dashboard
[root@master01 dashboard]# kubectl get services -n kubernetes-dashboard
[root@master01 dashboard]# kubectl get pods -o wide -n kubernetes-dashboard

提示：master01 NodePort 30001/TCP映射到 dashboard pod 443 端口。

創建管理員賬戶

提示：dashboard v2版本默認沒有創建具有管理員權限的賬戶，可如下操作創建。

[root@master01 dashboard]# vi dashboard-admin.yaml
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard

[root@master01 dashboard]# kubectl apply -f dashboard-admin.yaml

ingress暴露dashboard

創建ingress tls

[root@master01 ~]# cd /root/dashboard/certs
[root@master01 certs]# kubectl -n kubernetes-dashboard create secret tls kubernetes-dashboard-tls --cert=tls.crt --key=tls.key
[root@master01 certs]# kubectl -n kubernetes-dashboard describe secrets kubernetes-dashboard-tls

創建ingress策略

[root@master01 ~]# cd /root/dashboard/
[root@master01 dashboard]# vi dashboard-ingress.yaml
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: kubernetes-dashboard-ingress
  namespace: kubernetes-dashboard
  annotations:
    kubernetes.io/ingress.class: "nginx"
    nginx.ingress.kubernetes.io/use-regex: "true"
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    #nginx.ingress.kubernetes.io/secure-backends: "true"
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
    nginx.ingress.kubernetes.io/proxy-connect-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
    nginx.ingress.kubernetes.io/configuration-snippet: |
      proxy_ssl_session_reuse off;
spec:
  rules:
  - host: k8s.odocker.com
    http:
      paths:
      - path: /
        backend:
          serviceName: kubernetes-dashboard
          servicePort: 443
  tls:
  - hosts:
    - k8s.odocker.com
    secretName: kubernetes-dashboard-tls

[root@master01 dashboard]# kubectl apply -f dashboard-ingress.yaml
[root@master01 dashboard]# kubectl -n kubernetes-dashboard get ingress

訪問dashboard

導入證書

將k8s.odocker.com導入瀏覽器，並設置為信任，導入操作略。

創建kubeconfig文件

使用token相對複雜，可將token添加至kubeconfig文件中，使用KubeConfig文件訪問dashboard。

[root@master01 dashboard]# ADMIN_SECRET=$(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}') 
[root@master01 dashboard]# DASHBOARD_LOGIN_TOKEN=$(kubectl describe secret -n kubernetes-dashboard ${ADMIN_SECRET} | grep -E '^token' | awk '{print $2}') 
[root@master01 dashboard]# kubectl config set-cluster kubernetes \
  --certificate-authority=/etc/kubernetes/pki/ca.crt \
  --embed-certs=true \
  --server=172.24.8.100:16443 \
  --kubeconfig=local-ngkek8s-dashboard-admin.kubeconfig		# 設置集群參數
 [root@master01 dashboard]# kubectl config set-credentials dashboard_user \
  --token=${DASHBOARD_LOGIN_TOKEN} \
  --kubeconfig=local-ngkek8s-dashboard-admin.kubeconfig		# 設置客戶端認證參數，使用上面創建的 Token
[root@master01 dashboard]# kubectl config set-context default \
  --cluster=kubernetes \
  --user=dashboard_user \
  --kubeconfig=local-ngkek8s-dashboard-admin.kubeconfig		# 設置上下文參數
[root@master01 dashboard]# kubectl config use-context default --kubeconfig=local-ngkek8s-dashboard-admin.kubeconfig		# 設置默認上下文

將local-ngkek8s-dashboard-admin.kubeconfig文件導入，以便於瀏覽器使用該文件登錄。

測試訪問dashboard

本實驗採用ingress所暴露的域名：https://k8s.odocker.com 方式訪問。使用local-ngkek8s-dashboard-admin.kubeconfig文件訪問。

提示： 更多dashboard訪問方式及認證可參考附004.Kubernetes Dashboard簡介及使用。 dashboard登錄整個流程可參考：https://www.cnadn.net/post/2613.html

Longhorn存儲部署

Longhorn概述

Longhorn是用於Kubernetes的開源分佈式塊存儲系統。
提示：更多介紹參考：https://github.com/longhorn/longhorn。

Longhorn部署

[root@master01 ~]# source environment.sh
[root@master01 ~]# for all_ip in ${ALL_IPS[@]}
  do
    echo ">>> ${all_ip}"
    ssh root@${all_ip} "yum -y install iscsi-initiator-utils &"
  done

提示：所有節點都需要安裝。

[root@master01 ~]# mkdir longhorn
[root@master01 ~]# cd longhorn/
[root@master01 longhorn]# wget \
https://raw.githubusercontent.com/longhorn/longhorn/master/deploy/longhorn.yaml

[root@master01 longhorn]# vi longhorn.yaml
#……
---
kind: Service
apiVersion: v1
metadata:
  labels:
    app: longhorn-ui
  name: longhorn-frontend
  namespace: longhorn-system
spec:
  type: NodePort			#修改為nodeport
  selector:
    app: longhorn-ui
  ports:
  - port: 80
    targetPort: 8000
    nodePort: 30002
---
……
kind: DaemonSet
……
        imagePullPolicy: IfNotPresent
……
#……

[root@master01 longhorn]# kubectl apply -f longhorn.yaml
[root@master01 longhorn]# kubectl -n longhorn-system get pods -o wide

提示：若部署異常可刪除重建，若出現無法刪除namespace，可通過如下操作進行刪除：

wget https://github.com/longhorn/longhorn/blob/master/uninstall/uninstall.yaml
rm -rf /var/lib/longhorn/
kubectl apply -f uninstall.yaml
kubectl delete -f longhorn.yaml

動態sc創建

提示：默認longhorn部署完成已創建一個sc，也可通過如下手動編寫yaml創建。

 [root@master01 longhorn]# kubectl get sc
NAME                   PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
……
longhorn               driver.longhorn.io      Delete          Immediate              true                   15m

[root@master01 longhorn]# vi longhornsc.yaml
kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: longhornsc
provisioner: rancher.io/longhorn
parameters:
  numberOfReplicas: "3"
  staleReplicaTimeout: "30"
  fromBackup: "" 

[root@master01 longhorn]# kubectl create -f longhornsc.yaml

測試PV及PVC

[root@master01 longhorn]# vi longhornpod.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: longhorn-pvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: longhorn
  resources:
    requests:
      storage: 2Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: longhorn-pod
  namespace: default
spec:
  containers:
  - name: volume-test
    image: nginx:stable-alpine
    imagePullPolicy: IfNotPresent
    volumeMounts:
    - name: volv
      mountPath: /data
    ports:
    - containerPort: 80
  volumes:
  - name: volv
    persistentVolumeClaim:
      claimName: longhorn-pvc

[root@master01 longhorn]# kubectl apply -f longhornpod.yaml
[root@master01 longhorn]# kubectl get pods
[root@master01 longhorn]# kubectl get pvc
[root@master01 longhorn]# kubectl get pv

創建ingress訪問UI

[root@master01 longhorn]# yum -y install httpd-tools
[root@master01 longhorn]# htpasswd -c auth xhy			#創建用戶名和密碼

提示：也可通過如下命令創建：
USER=xhy; PASSWORD=x120952576; echo "${USER}:$(openssl passwd -stdin -apr1 <<< ${PASSWORD})" >> auth

[root@master01 longhorn]# kubectl -n longhorn-system create secret generic longhorn-basic-auth --from-file=auth

[root@master01 longhorn]# vi longhorn-ingress.yaml		#創建ingress規則
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: longhorn-ingress
  namespace: longhorn-system
  annotations:
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: longhorn-basic-auth
    nginx.ingress.kubernetes.io/auth-realm: 'Authentication Required '
spec:
  rules:
  - host: longhorn.odocker.com
    http:
      paths:
      - path: /
        backend:
          serviceName: longhorn-frontend
          servicePort: 80

[root@master01 longhorn]# kubectl apply -f longhorn-ingress.yaml

確認驗證

瀏覽器訪問：longhorn.odocker.com，並輸入賬號和密碼。

登錄查看。

Helm安裝

參考053.集群管理-Helm工具

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化