Kong 2-0 升級指南

Kong 2.0 升級指南

原文地址:https://docs.konghq.com/2.0.x/upgrading/ (不能保證所有的翻譯都是準確無誤的,所有如有翻譯的不準確或錯誤之處,請一定記得查看原文,並歡迎留言指出)

注意: 下面是 2.0.x 的升級指南。如果您試圖升級到早期版本的 Kong,請閱讀 upgrade.md 文件。

本指南將告訴您在升級時應該注意的重大更改,並指導您完成正確的步驟順序,以便在不同的升級場景中實現無停機遷移。

升級到 2.0.0

Kong 堅持語義化版本,區分 “主要”、“次要” 和“補丁”版本。升級路徑與您要遷移的前一個版本不同。升級到 2.0。是一個主要的版本升級,所以要注意在 CHANGELOG.md 文檔中列出的任何重大更改。

1. 依賴項

如果您正在使用已提供的二進制包,那麼所有必要的依賴項都已綁定,可以跳過此部分。

如果您是手動構建您的依賴項,那麼自上一個版本以來有一些更改,因此您將需要使用最新的補丁重新構建它們。

所需的 OpenResty 版本是 1.15.8.2,其中包含的 OpenResty 補丁集已經改變,包括最新版本的 lua-kong-nginx-module。我們的 kong-build-tools 庫允許您輕鬆地使用必要的補丁和模塊構建 OpenResty。

對於 GO 的支持,你還需要 Kong go-pluginserver。這是與 Kong 二進制包綁定的,如果在 Kong 的配置中啓用 Go 插件支持,它會自動啓動。注意,用於編譯任何 Go 插件的 Go 版本需要匹配go-pluginserver的 Go 版本。可以檢查用於構建運行go-pluginserver版本的gopluginserver二進制文件的 Go 版本。

2. 重大修改項

Kong 2.0.0 包含了對 Kong 1.x 的一些重大更改,且都和移除 Service Mesh 相關:

Nginx 配置改變如下:

diff --git a/kong/templates/nginx_kong.lua b/kong/templates/nginx_kong.lua
index 5c6c1db03..6b4b4a818 100644
--- a/kong/templates/nginx_kong.lua
+++ b/kong/templates/nginx_kong.lua
@@ -5,52 +5,46 @@ server_tokens off;
 > if anonymous_reports then
 $
 > end
-
 error_log $ $;

-> if nginx_optimizations then
->-- send_timeout 60s;          # default value
->-- keepalive_timeout 75s;     # default value
->-- client_body_timeout 60s;   # default value
->-- client_header_timeout 60s; # default value
->-- tcp_nopush on;             # disabled until benchmarked
->-- proxy_buffer_size 128k;    # disabled until benchmarked
->-- proxy_buffers 4 256k;      # disabled until benchmarked
->-- proxy_busy_buffers_size 256k; # disabled until benchmarked
->-- reset_timedout_connection on; # disabled until benchmarked
-> end
-
-client_max_body_size $;
-proxy_ssl_server_name on;
-underscores_in_headers on;
-
 lua_package_path       '$;;';
 lua_package_cpath      '$;;';
 lua_socket_pool_size   $;
+lua_socket_log_errors  off;
 lua_max_running_timers 4096;
 lua_max_pending_timers 16384;
+lua_ssl_verify_depth   $;
+> if lua_ssl_trusted_certificate then
+lua_ssl_trusted_certificate '$';
+> end
+
 lua_shared_dict kong                        5m;
+lua_shared_dict kong_locks                  8m;
+lua_shared_dict kong_healthchecks           5m;
+lua_shared_dict kong_process_events         5m;
+lua_shared_dict kong_cluster_events         5m;
+lua_shared_dict kong_rate_limiting_counters 12m;
+lua_shared_dict kong_core_db_cache          $;
+lua_shared_dict kong_core_db_cache_miss     12m;
 lua_shared_dict kong_db_cache               $;
-> if database == "off" then
-lua_shared_dict kong_db_cache_2     $;
-> end
 lua_shared_dict kong_db_cache_miss          12m;
 > if database == "off" then
+lua_shared_dict kong_core_db_cache_2        $;
+lua_shared_dict kong_core_db_cache_miss_2   12m;
+lua_shared_dict kong_db_cache_2             $;
 lua_shared_dict kong_db_cache_miss_2        12m;
 > end
-lua_shared_dict kong_locks          8m;
-lua_shared_dict kong_process_events 5m;
-lua_shared_dict kong_cluster_events 5m;
-lua_shared_dict kong_healthchecks   5m;
-lua_shared_dict kong_rate_limiting_counters 12m;
 > if database == "cassandra" then
 lua_shared_dict kong_cassandra              5m;
 > end
-lua_socket_log_errors off;
-> if lua_ssl_trusted_certificate then
-lua_ssl_trusted_certificate '$';
+> if role == "control_plane" then
+lua_shared_dict kong_clustering             5m;
+> end
+
+underscores_in_headers on;
+> if ssl_ciphers then
+ssl_ciphers $;
 > end
-lua_ssl_verify_depth $;

 # injected nginx_http_* directives
 > for _, el in ipairs(nginx_http_directives) do
@@ -66,61 +60,47 @@ init_worker_by_lua_block {
     Kong.init_worker()
 }

-
-> if #proxy_listeners > 0 then
+> if (role == "traditional" or role == "data_plane") and #proxy_listeners > 0 then
 upstream kong_upstream {
     server 0.0.0.1;
     balancer_by_lua_block {
         Kong.balancer()
     }

-# injected nginx_http_upstream_* directives
-> for _, el in ipairs(nginx_http_upstream_directives) do
+    # injected nginx_upstream_* directives
+> for _, el in ipairs(nginx_upstream_directives) do
     $(el.name) $(el.value);
 > end
 }

 server {
     server_name kong;
-> for i = 1, #proxy_listeners do
-    listen $(proxy_listeners[i].listener);
+> for _, entry in ipairs(proxy_listeners) do
+    listen $(entry.listener);
 > end
+
     error_page 400 404 408 411 412 413 414 417 494 /kong_error_handler;
     error_page 500 502 503 504                     /kong_error_handler;

     access_log $;
     error_log  $ $;

-    client_body_buffer_size $;
-
 > if proxy_ssl_enabled then
     ssl_certificate     $;
     ssl_certificate_key $;
+    ssl_session_cache   shared:SSL:10m;
     ssl_certificate_by_lua_block {
         Kong.ssl_certificate()
     }
-
-    ssl_session_cache shared:SSL:10m;
-    ssl_session_timeout 10m;
-    ssl_prefer_server_ciphers on;
-    ssl_ciphers $;
-> end
-
-> if client_ssl then
-    proxy_ssl_certificate $;
-    proxy_ssl_certificate_key $;
-> end
-
-    real_ip_header     $;
-    real_ip_recursive  $;
-> for i = 1, #trusted_ips do
-    set_real_ip_from   $(trusted_ips[i]);
 > end

     # injected nginx_proxy_* directives
 > for _, el in ipairs(nginx_proxy_directives) do
     $(el.name) $(el.value);
 > end
+> for i = 1, #trusted_ips do
+    set_real_ip_from  $(trusted_ips[i]);
+> end

     rewrite_by_lua_block {
         Kong.rewrite()
@@ -171,43 +151,93 @@ server {
         proxy_pass_header     Server;
         proxy_pass_header     Date;
         proxy_ssl_name        $upstream_host;
+        proxy_ssl_server_name on;
+> if client_ssl then
+        proxy_ssl_certificate $;
+        proxy_ssl_certificate_key $;
+> end
         proxy_pass            $upstream_scheme://kong_upstream$upstream_uri;
     }

     location @grpc {
         internal;
+        default_type         '';
         set $kong_proxy_mode 'grpc';

+        grpc_set_header      TE                $upstream_te;
         grpc_set_header      Host              $upstream_host;
         grpc_set_header      X-Forwarded-For   $upstream_x_forwarded_for;
         grpc_set_header      X-Forwarded-Proto $upstream_x_forwarded_proto;
         grpc_set_header      X-Forwarded-Host  $upstream_x_forwarded_host;
         grpc_set_header      X-Forwarded-Port  $upstream_x_forwarded_port;
         grpc_set_header      X-Real-IP         $remote_addr;
-
+        grpc_pass_header     Server;
+        grpc_pass_header     Date;
         grpc_pass            grpc://kong_upstream;
     }

     location @grpcs {
         internal;
+        default_type         '';
         set $kong_proxy_mode 'grpc';

+        grpc_set_header      TE                $upstream_te;
         grpc_set_header      Host              $upstream_host;
         grpc_set_header      X-Forwarded-For   $upstream_x_forwarded_for;
         grpc_set_header      X-Forwarded-Proto $upstream_x_forwarded_proto;
         grpc_set_header      X-Forwarded-Host  $upstream_x_forwarded_host;
         grpc_set_header      X-Forwarded-Port  $upstream_x_forwarded_port;
         grpc_set_header      X-Real-IP         $remote_addr;
-
+        grpc_pass_header     Server;
+        grpc_pass_header     Date;
+        grpc_ssl_name        $upstream_host;
+        grpc_ssl_server_name on;
+> if client_ssl then
+        grpc_ssl_certificate $;
+        grpc_ssl_certificate_key $;
+> end
         grpc_pass            grpcs://kong_upstream;
     }

+    location = /kong_buffered_http {
+        internal;
+        default_type         '';
+        set $kong_proxy_mode 'http';
+
+        rewrite_by_lua_block       {;}
+        access_by_lua_block        {;}
+        header_filter_by_lua_block {;}
+        body_filter_by_lua_block   {;}
+        log_by_lua_block           {;}
+
+        proxy_http_version 1.1;
+        proxy_set_header      TE                $upstream_te;
+        proxy_set_header      Host              $upstream_host;
+        proxy_set_header      Upgrade           $upstream_upgrade;
+        proxy_set_header      Connection        $upstream_connection;
+        proxy_set_header      X-Forwarded-For   $upstream_x_forwarded_for;
+        proxy_set_header      X-Forwarded-Proto $upstream_x_forwarded_proto;
+        proxy_set_header      X-Forwarded-Host  $upstream_x_forwarded_host;
+        proxy_set_header      X-Forwarded-Port  $upstream_x_forwarded_port;
+        proxy_set_header      X-Real-IP         $remote_addr;
+        proxy_pass_header     Server;
+        proxy_pass_header     Date;
+        proxy_ssl_name        $upstream_host;
+        proxy_ssl_server_name on;
+> if client_ssl then
+        proxy_ssl_certificate $;
+        proxy_ssl_certificate_key $;
+> end
+        proxy_pass            $upstream_scheme://kong_upstream$upstream_uri;
+    }
+
     location = /kong_error_handler {
         internal;
+        default_type                 '';
+
         uninitialized_variable_warn  off;

         rewrite_by_lua_block {;}
-
         access_by_lua_block  {;}

         content_by_lua_block {
@@ -215,13 +245,13 @@ server {
         }
     }
 }
-> end
+> end -- (role == "traditional" or role == "data_plane") and #proxy_listeners > 0

-> if #admin_listeners > 0 then
+> if (role == "control_plane" or role == "traditional") and #admin_listeners > 0 then
 server {
     server_name kong_admin;
-> for i = 1, #admin_listeners do
-    listen $(admin_listeners[i].listener);
+> for _, entry in ipairs(admin_listeners) do
+    listen $(entry.listener);
 > end

     access_log $;
@@ -233,11 +263,7 @@ server {
 > if admin_ssl_enabled then
     ssl_certificate     $;
     ssl_certificate_key $;
-
-    ssl_session_cache shared:SSL:10m;
-    ssl_session_timeout 10m;
-    ssl_prefer_server_ciphers on;
-    ssl_ciphers $;
+    ssl_session_cache   shared:AdminSSL:10m;
 > end

     # injected nginx_admin_* directives
@@ -265,20 +291,20 @@ server {
         return 200 'User-agent: *\nDisallow: /';
     }
 }
-> end
+> end -- (role == "control_plane" or role == "traditional") and #admin_listeners > 0

 > if #status_listeners > 0 then
 server {
     server_name kong_status;
-> for i = 1, #status_listeners do
-    listen $(status_listeners[i].listener);
+> for _, entry in ipairs(status_listeners) do
+    listen $(entry.listener);
 > end

     access_log $;
     error_log  $ $;

-    # injected nginx_http_status_* directives
-> for _, el in ipairs(nginx_http_status_directives) do
+    # injected nginx_status_* directives
+> for _, el in ipairs(nginx_status_directives) do
     $(el.name) $(el.value);
 > end

@@ -303,4 +329,26 @@ server {
     }
 }
 > end
+
+> if role == "control_plane" then
+server {
+    server_name kong_cluster_listener;
+> for _, entry in ipairs(cluster_listeners) do
+    listen $(entry.listener) ssl;
+> end
+
+    access_log off;
+
+    ssl_verify_client   optional_no_ca;
+    ssl_certificate     $;
+    ssl_certificate_key $;
+    ssl_session_cache   shared:ClusterSSL:10m;
+
+    location = /v1/outlet {
+        content_by_lua_block {
+            Kong.serve_cluster_listener()
+        }
+    }
+}
+> end -- role == "control_plane"
 ]]

3. 建議升級路徑

0.x升級到2.0.0

Kong 2.0.0 支持遷移的最低版本是 1.0.0。如果您是從低於 0.14.1 的版本遷移,那麼首先需要遷移到 0.14.1。然後,如果是從 0.14.1 開始遷移,請先升級到到 1.5.0。

從 0.14.1 升級到 1.5.0 的步驟與從 0.14.1 升級到 Kong 1.0 的步驟相同。請遵循 Kong 1.0 建議升級路徑中的 “從 0.14 遷移步驟” 中描述的步驟,並添加kong migrations migrate-apis命令,您可以使用該命令遷移保留apis配置。

當遷移到 1.5.0 之後,可以按照下面一節中的說明遷移到 2.0.0。

1.0.0 - 1.5.0 升級到 2.0.0

Kong 2.0.0 支持無停機遷移模型。這意味着在遷移過程中,您將運行兩個 Kong 集羣,共享相同的數據庫。(這有時被稱爲藍 / 綠遷移模型。)

遷移的設計使得不需要完全複製數據。但這也意味着它們的設計方式使得新版 Kong 能夠在遷移過程中使用數據,並且要以一種方式來完成它,使舊的 Kong 集羣能夠一直工作,直到它最終下線。由於這個原因,整個遷移現在分成兩個步驟,通過命令kong migrations up(只執行非破性操作) 和kong migrations finish(將數據庫置於 kong 2.0.0 的最終預期狀態) 執行。

  1. 下載 2.0.0,並將其配置爲指向與舊集羣 (1.0 到 1.5) 相同的數據存儲。運行kong migration up
  2. 一旦它完成運行,舊集羣和新集羣 (2.0.0) 現在可以在同一個數據存儲上同時運行。開始供應 2.0.0 節點,但還不使用它們的管理 API。如果需要執行管理 API 請求,應該對舊集羣的節點執行這些請求。其原因是爲了防止新集羣生成舊集羣無法識別的數據。
  3. 逐漸將流量從舊節點轉移到 2.0.0 集羣中。監控你的流程以確保一切順利。
  4. 當您的流量完全遷移到 2.0.0 集羣時,下線您的舊節點。
  5. 在 2.0.0 集羣中運行:kong migration finish。從現在起,將不能在舊集羣中啓動指向相同數據存儲的節點。只有在確信遷移成功時才運行此命令。從現在開始,您可以安全地向 2.0.0 節點發出管理 API 請求。

在新的數據存儲上安裝 2.0.0

下面的命令應該用於從新的數據存儲準備新的 2.0.0 集羣:

$ kong migrations bootstrap [-c config]
$ kong start [-c config]
本文由 Readfog 進行 AMP 轉碼,版權歸原作者所有。
來源https://zhuanlan.zhihu.com/p/146096222