2. 程式人生 > 實用技巧 >Istio的流量管理(實操三)

Istio的流量管理(實操三)

阿新 • • 發佈：2020-08-28

Istio的流量管理(實操三)

涵蓋官方文件Traffic Management章節中的egress部分。其中有一小部分問題(已在下文標註)待官方解決。

目錄

訪問外部服務

由於啟用了istio的pod的出站流量預設都會被重定向到代理上，因此對叢集外部URL的訪問取決於代理的配置。預設情況下，Envoy代理會透傳對未知服務的訪問，雖然這種方式為新手提供了便利，但最好配置更嚴格的訪問控制。

本節展示使用如下三種方式訪問外部服務:

  1. 允許Envoy代理透傳到網格外部的服務
  2. 配置service entries來訪問外部訪問
  3. 透傳某一個IP端的請求

部署

  • 部署sleep app，用於傳送請求。

    $ kubectl apply -f samples/sleep/sleep.yaml

  • 設定SOURCE_POD為請求源pod名

    $ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

Envoy透傳流量到外部服務

istio有一個安裝選項，meshConfig.outboundTrafficPolicy.mode，用於配置sidecar處理外部服務(即沒有定義到istio內部服務註冊中心的服務)。如果該選項設定為ALLOW_ANY，則istio代理會放行到未知服務的請求；如果選項設定為REGISTRY_ONLY，則istio代理會阻塞沒有在網格中定義HTTP服務或服務表項的主機。預設值為ALLOW_ANY，允許快速對istio進行評估。

  1. 首先將meshConfig.outboundTrafficPolicy.mode選項設定為ALLOW_ANY。預設應該就是ALLOW_ANY，使用如下方式獲取當前的模式：

    $kubectl get configmap istio -n istio-system -o yaml |grep -o "mode: ALLOW_ANY" |uniq
mode: ALLOW_ANY

    如果沒有配置模式，可以手動新增：

    outboundTrafficPolicy: 
  mode: ALLOW_ANY

  2. 從網格內向外部服務傳送兩個請求，可以看到請求成功，返回200

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -I https://www.baidu.com | grep  "HTTP/"; kubectl exec -it $SOURCE_POD -c sleep -- curl -I https://edition.cnn.com | grep "HTTP/"
HTTP/1.1 200 OK
HTTP/2 200

    使用這種方式可以訪問外部服務，但無法對該流量進行監控和控制，下面介紹如何監控和控制網格到外部服務的流量。

控制訪問外部服務

使用ServiceEntry配置可以從istio叢集內部訪問公共服務。本節展示如何配置訪問外部HTTP服務，httpbin.org以及www.baidu.com，同時會監控和控制istio流量。

修改預設的阻塞策略

為了展示如何控制訪問外部服務的方式，需要將meshConfig.outboundTrafficPolicy.mode設定為REGISTRY_ONLY

  1. 執行如下命令將meshConfig.outboundTrafficPolicy.mode選項設定為REGISTRY_ONLY

    $ kubectl get configmap istio -n istio-system -o yaml | sed 's/mode: ALLOW_ANY/mode: REGISTRY_ONLY/g' | kubectl replace -n istio-system -f -

  2. 從SOURCE_POD訪問外部HTTPS服務，此時請求會被阻塞(可能需要等一段時間來使配置生效)

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -I https://www.baidu.com | grep  "HTTP/"; kubectl exec -it $SOURCE_POD -c sleep -- curl -I https://edition.cnn.com | grep "HTTP/"
command terminated with exit code 35
command terminated with exit code 35

訪問外部HTTP服務

  1. 建立一個ServiceEntry註冊外部服務，這樣就可以直接訪問外部HTTP服務，可以看到此處並沒有用到virtual service和destination rule

    下面serviceEntry使用DNS 作為resolution是一種比較安全的方式，將resolution設定為NONE將可能導致攻擊。例如，惡意客戶可能會再HOST首部中設定httpbin.org，但實際上訪問的不同的IP地址。istio sidecar代理會信任HOST首部，並錯誤地允許此次訪問(即使會將流量傳遞到不同於主機的IP地址)，該主機可能是一個惡意網站，或是一個被網格安全策略遮蔽的合法網站。

    使用DNS resolution時，sidecar代理會忽略原始目的地址，並將流量傳遞給hosts欄位的主機。在轉發流量前會使用DNS請求hosts欄位的IP地址。

    serviceEntry包括如下三種resolution：

    Name Description
    NONE Assume that incoming connections have already been resolved (to a specific destination IP address). Such connections are typically routed via the proxy using mechanisms such as IP table REDIRECT/ eBPF. After performing any routing related transformations, the proxy will forward the connection to the IP address to which the connection was bound.
    STATIC Use the static IP addresses specified in endpoints (see below) as the backing instances associated with the service.
    DNS Attempt to resolve the IP address by querying the ambient DNS, during request processing. If no endpoints are specified, the proxy will resolve the DNS address specified in the hosts field, if wildcards are not used. If endpoints are specified, the DNS addresses specified in the endpoints will be resolved to determine the destination IP address. DNS resolution cannot be used with Unix domain socket endpoints. 
    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: httpbin-ext
spec:
  hosts:
  - httpbin.org #外部服務URI
  ports:
  - number: 80 #外部服務HTTP埠資訊
    name: http
    protocol: HTTP
  resolution: DNS
  location: MESH_EXTERNAL # 表示一個外部服務，即httpbin.org是網格外部的服務
EOF

  2. 從SOURCE_POD請求外部HTTP服務

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl http://httpbin.org/headers
{
  "headers": {
    "Accept": "*/*",
    "Content-Length": "0",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.64.0",
    ...
    "X-Envoy-Decorator-Operation": "httpbin.org:80/*",
  }
}

    注意HTTP添加了istio sidecar代理首部X-Envoy-Decorator-Operation。

  3. 校驗SOURCE_POD sidecar代理的日誌(實際並沒有如同官方文件中的列印，issue跟蹤)

    $ kubectl logs $SOURCE_POD -c istio-proxy | tail

訪問外部HTTPS服務

  1. 建立ServiceEntry允許訪問外部HTTPS服務

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: baidu
spec:
  hosts:
  - www.baidu.com
  ports:
  - number: 443 # 外部服務HTTPS埠
    name: https
    protocol: HTTPS #指定外部服務為HTTPS協議
  resolution: DNS
  location: MESH_EXTERNAL
EOF

  2. 從SOURCE_POD訪問外部服務

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -I https://www.baidu.com | grep  "HTTP/"
HTTP/1.1 200 OK

管理到外部的流量

與管理叢集內部的流量類似，istio 的路由規則也可以管理使用ServiceEntry配置的外部服務。本例將會為httpbin.org服務設定一個超時規則.

  1. 從測試的pod向外部服務httpbin.org的/delay地址傳送一個請求，大概5s後返回200

    $ kubectl exec -it $SOURCE_POD -c sleep -- time curl -o /dev/null -s -w "%{http_code}\n" http://httpbin.org/delay/5
200
real    0m 5.43s
user    0m 0.00s
sys     0m 0.00s

  2. 對外部服務httpbin.org設定一個3s的超時時間

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: httpbin-ext
spec:
  hosts:
    - httpbin.org #此處的hosts與serviceEntry的hosts欄位內容對應
  http:
  - timeout: 3s
    route:
      - destination:
          host: httpbin.org 
        weight: 100
EOF

  3. 幾秒後，重新訪問該服務，可以看到訪問超時

    $ kubectl exec -it $SOURCE_POD -c sleep -- time curl -o /dev/null -s -w "%{http_code}\n" http://httpbin.org/delay/5
504
real    0m 3.02s
user    0m 0.00s
sys     0m 0.00s

解除安裝

$ kubectl delete serviceentry httpbin-ext google
$ kubectl delete virtualservice httpbin-ext --ignore-not-found=true

直接訪問外部服務

可以配置Envoy sidecar，使其不攔截特定IP段的請求。為了實現該功能，可以修改global.proxy.includeIPRanges或global.proxy.excludeIPRanges配置選項(類似白名單和黑名單)，並使用kubectl apply命令更新istio-sidecar-injector配置。也可以修改annotations traffic.sidecar.istio.io/includeOutboundIPRanges來達到相同的效果。在更新istio-sidecar-injector配置後，相應的變動會影響到所有的應用pod。

與使用ALLOW_ANY流量策略配置sidecar放行所有到未知服務的流量不同，上述方式會繞過sidecar的處理，即在特定IP段上不啟用istio功能。使用這種方式不能增量地為特定目的地新增service entry，但使用ALLOW_ANY方式是可以的，因此這種方式僅僅建議用於效能測試或其他特殊場景中。

一種不把到外部IP的流量重定向到sidecar代理的方式是將global.proxy.includeIPRanges設定為叢集內部服務使用的一個IP段或多個IP段。

找到平臺使用的內部IP段後，就可以使用如下方式配置includeIPRanges，這樣目的地非10.0.0.1/24的流量會繞過sidecar的處理。

$ istioctl manifest apply <the flags you used to install Istio> --set values.global.proxy.includeIPRanges="10.0.0.1/24"

總結

本節介紹了三種訪問外部服務的方式:

  1. 配置Envoy 允許訪問外部服務
  2. 在網格內部使用service entry註冊可訪問的外部服務，推薦使用這種方式
  3. 配置istio sidecar排除處理某些IP段的流量

第一種方式的流量會經過istio sidecar代理，當使用這種方式時，無法監控訪問外部服務的流量，無法使用istio的流量控制功能。第二種方法可以在呼叫叢集內部或叢集外部的服務時充分使用istio服務網格特性，本章的例子中，在訪問外部服務時設定了超時時間。第三種方式會繞過istio sidecar代理，直接訪問外部服務。然而這種方式需要指定叢集的配置，與第一種方式類似，這種方式也無法監控到外部服務的流量，且無法使用istio的功能。

解除安裝

$ kubectl delete -f samples/sleep/sleep.yaml

環境恢復

檢查當前的模式

$ kubectl get configmap istio -n istio-system -o yaml | grep -o "mode: ALLOW_ANY" | uniq
$ kubectl get configmap istio -n istio-system -o yaml | grep -o "mode: REGISTRY_ONLY" | uniq

將模式從ALLOW_ANY切換到REGISTRY_ONLY

$ kubectl get configmap istio -n istio-system -o yaml | sed 's/mode: ALLOW_ANY/mode: REGISTRY_ONLY/g' | kubectl replace -n istio-system -f -

將模式從REGISTRY_ONLY切換到ALLOW_ANY

$ kubectl get configmap istio -n istio-system -o yaml | sed 's/mode: REGISTRY_ONLY/mode: ALLOW_ANY/g' | kubectl replace -n istio-system -f -

Egress TLS Origination(Egress TLS源)

本節展示如何通過配置istio來(對到外部服務的流量)初始化TLS。當原始流量為HTTP時，Istio會與外部服務建立HTTPS連線，即istio會加密到外部服務的請求。

建立sleep應用

$ kubectl apply -f samples/sleep/sleep.yaml

獲取sleep的pod名

$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

建立ServiceEntry 和VirtualService訪問 edition.cnn.com

$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: edition-cnn-com
spec:
  hosts:
  - edition.cnn.com #外部服務URI
  ports:
  - number: 80     # HTTP訪問
    name: http-port
    protocol: HTTP
  - number: 443    # HTTPS訪問
    name: https-port
    protocol: HTTPS #指定外部服務為HTTPS協議
  resolution: DNS
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: edition-cnn-com
spec:
  hosts:
  - edition.cnn.com #外部服務URI
  tls: #非終結的TLS&HTTPS流量
  - match: #將edition.cnn.com:443的流量分發到edition.cnn.com:443
    - port: 443
      sniHosts:
      - edition.cnn.com
    route:
    - destination:
        host: edition.cnn.com
        port:
          number: 443
      weight: 100
EOF

訪問外部服務，下面使用了-L選項使請求端依照返回的重定向資訊重新發起請求。第一個請求會發往http://edition.cnn.com/politics，服務端會返回重定向資訊，第二個請求會按照重定向資訊發往https://edition.cnn.com/politics。可以看到第一次是HTTP訪問，第二次是HTTPS訪問。

如果沒有上述VirtualService，也可以通過下面命令進行訪問。此處應該是為了與下面例子結合。

$ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics

HTTP/1.1 301 Moved Permanently
...
location: https://edition.cnn.com/politics
...

HTTP/2 200
...

上述過程會有兩個弊端：上面的第一個HTTP訪問顯然是冗餘的；如果在應用和edition.cnn.com 之間存在攻擊者，這樣該攻擊者就可以通過嗅探鏈路獲取請求端執行的操作，存在安全風險。

使用istio的TLS源可以解決如上問題。

為Egress流量配置TLS源

重新定義 ServiceEntry 和VirtualService ，並增加DestinationRule來發起TLS。此時VirtualService會將HTTP請求流量從80埠重定向到DestinationRule的443埠，然後由DestinationRule來發起TLS。

$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry # serviceEntry跟前面配置一樣
metadata:
  name: edition-cnn-com
spec:
  hosts:
  - edition.cnn.com #註冊到註冊中心的host。用於選擇virtualService和DestinationRule
  ports:
  - number: 80
    name: http-port
    protocol: HTTP
  - number: 443
    name: https-port-for-tls-origination
    protocol: HTTPS
  resolution: DNS
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: edition-cnn-com #請求的hosts欄位
spec:
  hosts:
  - edition.cnn.com #請求中的hosts欄位內容
  http:
  - match:
    - port: 80 #後續將http流量通過destinationrule轉換為https流量
    route:
    - destination:
        host: edition.cnn.com #此時定義了DestinationRule，會經過DestinationRule處理
        subset: tls-origination
        port:
          number: 443
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: edition-cnn-com
spec:
  host: edition.cnn.com #istio登錄檔中的服務
  subsets:
  - name: tls-origination
    trafficPolicy:
      loadBalancer:
        simple: ROUND_ROBIN
      portLevelSettings: #配置與上游服務edition.cnn.com的連線。即在443埠上使用tls SIMPLE進行連線
      - port:
          number: 443
        tls:
          mode: SIMPLE # initiates HTTPS when accessing edition.cnn.com
EOF

向http://edition.cnn.com/politics傳送請求，可以看到此時會返回200，且不會經過重定向，相當於做了一個代理。

$ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics
HTTP/1.1 200 OK
...

當然直接使用https進行訪問也是可以的，與上面使用http進行訪問的結果相同kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - https://edition.cnn.com/politics

需要考慮的安全性問題

由於應用和sidecar代理之間是沒有加密。因此滲透到應用所在的node節點的攻擊者仍然能夠看到該節點上未加密的本地通訊內容。對於安全性較高的場景，建議應用直接使用HTTPS。

解除安裝

$ kubectl delete serviceentry edition-cnn-com
$ kubectl delete virtualservice edition-cnn-com
$ kubectl delete destinationrule edition-cnn-com
$ kubectl delete -f samples/sleep/sleep.yaml

Egress 閘道器

本節描述如何通過一個指定的egress閘道器訪問外部服務。istio使用ingress和egress閘道器在服務網格邊界配置負載均衡。一個ingress閘道器允許定義網格的入站點，egress閘道器的用法類似，定義了網格內流量的出站點。

使用場景

假設在一個安全要求比較高的組織中，所有離開服務網格的流量都要經過一個指定的節點(前面的egress訪問都是在離開pod之後按照k8s方式訪問，並沒有指定必須經過某個節點)，這些節點會執行在指定的機器上，與執行應用的叢集的節點分開。這些特定的節點會在出站流量上應用策略，且對這些節點的監控將更加嚴格。

另外一個場景是叢集中的應用所在的節點沒有公網IP，因此網格內部的服務無法訪問因特網。定義一個egress閘道器併為該閘道器所在的節點分配公網IP，這樣流量就可以通過該節點訪問公網服務。

環境配置

建立sleep應用並獲取Pod名

$ kubectl apply -f samples/sleep/sleep.yaml
$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

部署Istio egress閘道器

校驗是否已經部署istio egress閘道器

$ kubectl get pod -l istio=egressgateway -n istio-system

如果沒有部署，執行如下步驟部署egress閘道器

$ istioctl manifest apply -f cni-annotations.yaml --set values.global.istioNamespace=istio-system --set values.gateways.istio-ingressgateway.enabled=true --set values.gateways.istio-egressgateway.enabled=true

注意：apply的時候使用自己定製化的檔案，否則系統會使用預設的profile，導致配置丟失！

下面操作關於在default名稱空間中為egress閘道器建立destination rule，因此要求sleep應用也部署在default名稱空間中。如果應用不在default名稱空間中，將無法在destination rule查詢路徑找到destination rule，客戶端請求將會失敗。

HTTP流量的egress閘道器

  1. 上面例子中，當網格內的客戶端可以直接訪問外部服務，此處將會建立一個egress閘道器，內部流量訪問外部服務時會經過該閘道器。建立一個ServiceEntry允許流量訪問外部服務edition.cnn.com:

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: cnn
spec:
  hosts:
  - edition.cnn.com
  ports: #可以通過HTTP和HTTPS服務外部服務
  - number: 80
    name: http-port
    protocol: HTTP
  - number: 443
    name: https
    protocol: HTTPS
  resolution: DNS
EOF

  2. 校驗請求能夠發往http://edition.cnn.com/politics，此處的操作與上一節相同。

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics
HTTP/1.1 301 Moved Permanently
...

HTTP/2 200
...

  3. 為edition.cnn.com建立一個Gateway，埠80，監聽來自edition.cnn.com:80的流量。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port: #監聽來自edition.cnn.com:80的流量，
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - edition.cnn.com
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule #該DestinationRule沒有定義任何規則，實際可以刪除該DestinationRule，並刪除下面VirtualService的"subset: cnn"一行
metadata:
  name: egressgateway-for-cnn
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: cnn #下面VirtualService中會用到
EOF

  4. 定義VirtualService，將流量從sidecar定向到egress閘道器，然後將流量從egress閘道器定向到外部服務。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-cnn-through-egress-gateway
spec:
  hosts:
  - edition.cnn.com
  gateways: #列出應用路由規則的閘道器
  - istio-egressgateway
  - mesh #istio保留欄位，表示網格中的所有sidecar，當忽略gateways欄位時，預設會使用mesh，此處表示所有sidecar到edition.cnn.com的請求
  http: #採用http路由規則
  - match: #各個match是OR關係
    - gateways: #處理mesh閘道器，將來自mesh的edition.cnn.com:80請求發往istio-egressgateway.istio-system.svc.cluster.local:80
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: cnn #對應DestinationRule中的subset名，由於使用了subset，因此必須使用DestinationRule。刪除該行後就可以不使用上面的DestinationRule
        port:
          number: 80
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway #處理istio-egressgateway閘道器，將來自gateway edition.cnn.com:80的請求發往edition.cnn.com:80
      port: 80
    route:
    - destination:
        host: edition.cnn.com #該host就對應serviceEntry註冊的服務地址
        port:
          number: 80
      weight: 100
EOF

  5. 傳送HTTP請求http://edition.cnn.com/politics

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics
HTTP/1.1 301 Moved Permanently
...

HTTP/2 200
...

  6. 校驗egress日誌（需要啟用Envoy日誌）

    $ kubectl logs -l istio=egressgateway -c istio-proxy -n istio-system | tail
[2020-08-25T14:55:49.810Z] "GET /politics HTTP/2" 301 - "-" "-" 0 0 1445 1444 "10.80.3.231" "curl/7.64.0" "2151bde2-4382-4e2f-b088-e464943c2a9b" "edition.cnn.com" "151.101.1.67:80" outbound|80||edition.cnn.com 10.80.3.232:51516 10.80.3.232:8080 10.80.3.231:38072 - -

本例中仍然實在sleep pod中執行HTTP請求，通過301重定向重新發送HTTPS請求，而上面規則中並沒有將HTTPs流程轉發給閘道器，因此從上面閘道器上看不到到443埠的流量，但可以在sleep的istio-proxy sidecar的日誌中可以看到完整的流量資訊，如下：

[2020-08-25T14:55:33.114Z] "GET /politics HTTP/1.1" 301 - "-" "-" 0 0 310 310 "-" "curl/7.64.0" "d57ddf5f-985b-431a-8766-7481b75dc486" "edition.cnn.com" "151.101.1.67:80" outbound|80||edition.cnn.com 10.80.3.231:48390 151.101.65.67:80 10.80.3.231:44674 - default
[2020-08-25T14:55:33.439Z] "- - -" 0 - "-" "-" 906 1326852 5490 - "-" "-" "-" "-" "151.101.129.67:443" outbound|443||edition.cnn.com 10.80.3.231:47044 151.101.65.67:443 10.80.3.231:42990 edition.cnn.com -

解除安裝

$ kubectl delete gateway istio-egressgateway
$ kubectl delete serviceentry cnn
$ kubectl delete virtualservice direct-cnn-through-egress-gateway
$ kubectl delete destinationrule egressgateway-for-cnn

HTTPS流量的egress gateway

本節展示通過egress閘道器定向HTTPS流量，。會使用到ServiceEntry，一個egress Gateway和一個VirtualService。

  1. 建立到edition.cnn.com的ServiceEntry，定義外部服務https://edition.cnn.com

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: cnn
spec:
  hosts:
  - edition.cnn.com
  ports:
  - number: 443
    name: tls
    protocol: TLS #protocol為TLS，用於非終結的流量
  resolution: DNS
EOF

    protocol欄位可以為HTTP|HTTPS|GRPC|HTTP2|MONGO|TCP|TLS其中之一，其中TLS 表示不會終止TLS連線，且連線會基於SNI首部進行路由。

  2. 校驗可以通過ServiceEntry訪問https://edition.cnn.com/politics

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - https://edition.cnn.com/politics
HTTP/2 200
...

  3. 為edition.cnn.com建立egress Gateway，一個destination rule和一個virtual service。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port:
      number: 443
      name: tls
      protocol: TLS #該欄位與serviceEntry的欄位相同
    hosts:
    - edition.cnn.com
    tls:
      mode: PASSTHROUGH #透傳模式，不在閘道器上終止TLS，由sidecar發起TLS
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-cnn
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: cnn
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-cnn-through-egress-gateway
spec:
  hosts:
  - edition.cnn.com
  gateways:
  - mesh
  - istio-egressgateway
  tls: #此處由http變為了tls
  - match:
    - gateways:
      - mesh
      port: 443
      sniHosts:
      - edition.cnn.com #基於SNI的路由
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: cnn
        port:
          number: 443
  - match:
    - gateways:
      - istio-egressgateway
      port: 443
      sniHosts:
      - edition.cnn.com #指定tls的SNI
    route:
    - destination:
        host: edition.cnn.com
        port:
          number: 443
      weight: 100
EOF

    由於TLS本身是加密的，無法像HTTP一樣根據host首部欄位進行路由管理，因此採用了SNI擴充套件。SNI位於TLS協商的client-hello階段，作為client-hello的擴充套件欄位存在，基於TLS SNI的路由與基於HTTP host首部欄位的路由管理，在邏輯上是相同的。SNI也支援萬用字元模式。

  4. 訪問https://edition.cnn.com/politics

    $ kubectl exec -it $SOURCE_POD -c sleep -- curl -sL -o /dev/null -D - https://edition.cnn.com/politics
HTTP/2 200
...

  5. 校驗log

    $ kubectl logs -l istio=egressgateway -n istio-system
...
[2020-06-02T09:06:43.152Z] "- - -" 0 - "-" "-" 906 1309129 1282 - "-" "-" "-" "-" "151.101.193.67:443" outbound|443||edition.cnn.com 10.83.1.219:39574 10.83.1.219:443 10.80.3.25:35492 edition.cnn.com -

解除安裝

$ kubectl delete serviceentry cnn
$ kubectl delete gateway istio-egressgateway
$ kubectl delete virtualservice direct-cnn-through-egress-gateway
$ kubectl delete destinationrule egressgateway-for-cnn

安全考量

istio不能保證所有通過egress網關出去的流量的安全性，僅能保證通過sidecar代理的流量的安全性。如果攻擊者繞過了sidecar代理，就可以不經過egress閘道器直接訪問外部服務。此時，攻擊者的行為不受istio的控制和監控。叢集管理員或雲供應商必須保證所有的流量都要經過egress閘道器。例如，叢集管理員可以配置一個防火牆，拒絕所有非egress閘道器的流量。Kubernetes network policies也可以禁止所有非egress閘道器的流量。此外，叢集管理員或雲供應商可以配置網路來保證應用節點只能通過閘道器訪問因特網，為了實現這種效果，需要阻止將公共IP分配給閘道器以外的pod，並配置NAT裝置丟棄非egress閘道器的報文。

使用Kubernetes network policies

本節展示如何建立一個Kubernetes network policy來防止繞過egress閘道器。為了測試網路策略，需要建立一個名稱空間test-egress，部署sleep應用，並嘗試向閘道器安全的外部服務傳送請求。

首先完成中的egress-gateway-for-https-traffic步驟，然後執行如下操作

  1. 建立test-egress名稱空間

    $ kubectl create namespace test-egress

  2. 將sleep部署到test-egress名稱空間中

    $ kubectl apply -n test-egress -f samples/sleep/sleep.yaml

  3. 校驗部署的pod不存在istio sidecar

    $ kubectl get pod $(kubectl get pod -n test-egress -l app=sleep -o jsonpath={.items..metadata.name}) -n test-egress
NAME                    READY   STATUS    RESTARTS   AGE
sleep-f8cbf5b76-g2t2l   1/1     Running   0          27s

  4. 從 test-egress 名稱空間中的sleep pod向https://edition.cnn.com/politics 傳送HTTPS請求，返回200成功

    $ kubectl exec -it $(kubectl get pod -n test-egress -l app=sleep -o jsonpath={.items..metadata.name}) -n test-egress -c sleep -- curl -s -o /dev/null -w "%{http_code}\n"  https://edition.cnn.com/politics
200

  5. 在istio元件所在的名稱空間建立標籤，如果istio元件部署在istio-system名稱空間中，則操作方式如下：

    $ kubectl label namespace istio-system istio=system

  6. 給kube-system名稱空間打標籤

    $ kubectl label ns kube-system kube-system=true

  7. 部署一個NetworkPolicy限制從test-egress名稱空間到istio-system名稱空間和kube-system DNS服務的egress流量：

    $ cat <<EOF | kubectl apply -n test-egress -f -
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-egress-to-istio-system-and-kube-dns
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kube-system: "true"
    ports:
    - protocol: UDP
      port: 53
  - to:
    - namespaceSelector:
        matchLabels:
          istio: system
EOF

  8. 重新發送HTTPS請求到https://edition.cnn.com/politics，此時由於network policy阻止了流量，請求會失敗。由於sleep Pod無法繞過istio-egressgateway(需要環境保證，如果環境上即使沒有istio-egressgateway也能訪問外部服務，則此處可能會與預期不一樣，本人使用的openshift環境無法測試這種場景)訪問外部服務，唯一的方式是將流量定向到istio-egressgateway上。

    $ kubectl exec -it $(kubectl get pod -n test-egress -l app=sleep -o jsonpath={.items..metadata.name}) -n test-egress -c sleep -- curl -v https://edition.cnn.com/politics
Hostname was NOT found in DNS cache
  Trying 151.101.65.67...
  Trying 2a04:4e42:200::323...
Immediate connect fail for 2a04:4e42:200::323: Cannot assign requested address
  Trying 2a04:4e42:400::323...
Immediate connect fail for 2a04:4e42:400::323: Cannot assign requested address
  Trying 2a04:4e42:600::323...
Immediate connect fail for 2a04:4e42:600::323: Cannot assign requested address
  Trying 2a04:4e42::323...
Immediate connect fail for 2a04:4e42::323: Cannot assign requested address
connect to 151.101.65.67 port 443 failed: Connection timed out

  9. 現在給test-egress名稱空間的sleep pod注入istio sidecar代理

    $ kubectl label namespace test-egress istio-injection=enabled

  10. 重新在test-egress名稱空間中部署sleep deployment

    openshift環境需要首先執行如下步驟：

    $ cat <<EOF | oc -n test-egress create -f -
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: istio-cni
EOF

$ oc adm policy add-scc-to-group privileged system:serviceaccounts:test-egress
$ oc adm policy add-scc-to-group anyuid system:serviceaccounts:test-egress

    部署sleep應用

    $ kubectl delete deployment sleep -n test-egress
$ kubectl apply -f samples/sleep/sleep.yaml -n test-egress

  11. 校驗test-egress名稱空間的sleep注入了istio sidecar

    $ kubectl get pod $(kubectl get pod -n test-egress -l app=sleep -o jsonpath={.items..metadata.name}) -n test-egress -o jsonpath='{.spec.containers[*].name}'
sleep istio-proxy

  12. 建立與default名稱空間中相同的destination rule，將流量定向到egress閘道器：

    $ kubectl apply -n test-egress -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-cnn
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local #內部服務地址，不需要用serviceEntry
  subsets:
  - name: cnn
EOF

  13. 傳送HTTPS請求到https://edition.cnn.com/politics：

    $ kubectl exec -it $(kubectl get pod -n test-egress -l app=sleep -o jsonpath={.items..metadata.name}) -n test-egress -c sleep -- curl -s -o /dev/null -w "%{http_code}\n" https://edition.cnn.com/politics

  14. 校驗egress閘道器代理的日誌

    $ kubectl logs -l istio=egressgateway -n istio-system
...
[2020-06-02T09:04:11.239Z] "- - -" 0 - "-" "-" 906 1309030 1606 - "-" "-" "-" "-" "151.101.1.67:443" outbound|443||edition.cnn.com 10.83.1.219:56116 10.83.1.219:443 10.80.3.25:59032 edition.cnn.com -

解除安裝網路策略

$ kubectl delete -f samples/sleep/sleep.yaml -n test-egress
$ kubectl delete destinationrule egressgateway-for-cnn -n test-egress
$ kubectl delete networkpolicy allow-egress-to-istio-system-and-kube-dns -n test-egress
$ kubectl label namespace kube-system kube-system-
$ kubectl label namespace istio-system istio-
$ kubectl delete namespace test-egress

帶TLS源的Egress閘道器(檔案掛載)

在上一節的HTTPS流量的egress gateway中展示瞭如何配置istio來實現對外部服務的流量發起TLS。HTTP流量的egress閘道器中展示例子展示瞭如何配置istio來通過一個特定的egress網格服務來轉發egress流量。本節的例子將結合這兩個例子來描述如何配置一個egress閘道器來為到外部服務的流量發起TLS。

部署

在default(已啟用sidecar自動注入)名稱空間下安裝sleep

$ kubectl apply -f samples/sleep/sleep.yaml

獲取Pod名稱

$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

建立egress閘道器

$ istioctl install -f cni-annotations.yaml --set values.global.istioNamespace=istio-system --set values.gateways.istio-egressgateway.enabled=true  --set meshConfig.accessLogFile="/dev/stdout"

使用一個egress閘道器發起TLS

本節描述如何使用於HTTPS流量的egress gateway相同的方式發起TLS，但此處使用了一個egress閘道器。注意這種情況下，通過egress閘道器來發起TLS，而前面的例子中使用了sidecar發起TLS(curl時指定的是https://edition.cnn.com/politics)。

  1. 為edition.cnn.com定義一個ServiceEntry

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: cnn
spec:
  hosts:
  - edition.cnn.com
  ports:
  - number: 80
    name: http
    protocol: HTTP
  - number: 443
    name: https
    protocol: HTTPS
  resolution: DNS
EOF

  2. 校驗可以通過建立的ServiceEntry向http://edition.cnn.com/politics傳送請求

    # kubectl exec "${SOURCE_POD}" -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics
HTTP/1.1 301 Moved Permanently
...
location: https://edition.cnn.com/politics
...

  3. 為edition.cnn.com建立一個Gateway，監聽edition.cnn.com:80，以及一個destination rule來處理sidecar到egress閘道器的請求

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers: #配置閘道器暴露的主機資訊
  - port:
      number: 80
      name: https-port-for-tls-origination
      protocol: HTTPS
    hosts:
    - edition.cnn.com
    tls: 
      mode: ISTIO_MUTUAL #與閘道器的連線使用ISTIO_MUTUAL模式
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-cnn
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: cnn
    trafficPolicy:
      loadBalancer:
        simple: ROUND_ROBIN
      portLevelSettings: #基於單個埠的流量策略
      - port:
          number: 80
        tls: #與上游服務的連線設定，即到閘道器的tls配置，使用ISTIO_MUTUAL模式
          mode: ISTIO_MUTUAL
          sni: edition.cnn.com #表示TLS連線的服務端
EOF

  4. 定義一個VirtualService將流量轉移到egress閘道器，以及一個DestinationRule來為到edition.cnn.com的請求發起TLS。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-cnn-through-egress-gateway
spec:
  hosts:
  - edition.cnn.com
  gateways:
  - istio-egressgateway
  - mesh
  http:
  - match:
    - gateways: #處理來自網格內部所有到edition.cnn.com的流量，傳送到egress閘道器，並使用subset: cnn進行處理
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: cnn
        port:
          number: 80
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway #處理來自閘道器istio-egressgateway的流量，直接發往edition.cnn.com
      port: 80
    route:
    - destination:
        host: edition.cnn.com
        port:
          number: 443
      weight: 100
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: originate-tls-for-edition-cnn-com
spec:
  host: edition.cnn.com
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
    portLevelSettings:
    - port:
        number: 443
      tls:
        mode: SIMPLE # 閘道器到edition.cnn.com使用SIMPLE模式，由於edition.cnn.com是網格外部服務，因此不能使用ISTIO_MUTUAL
EOF

    整個過程為：網格內部HTTP流量->istio-egressgateway(配置TLS)->發起TLS連線

  5. 傳送HTTP請求到http://edition.cnn.com/politics

    # kubectl exec "${SOURCE_POD}" -c sleep -- curl -sL -o /dev/null -D - http://edition.cnn.com/politics
HTTP/1.1 200 OK

    此時的輸出中不包含301 Moved Permanently 訊息

  6. 校驗istio-egressgateway pod的日誌

    $ kubectl logs -l istio=egressgateway -c istio-proxy -n istio-system | tail

    可以看到如下輸出：

    [2020-08-25T15:16:17.840Z] "GET /politics HTTP/2" 200 - "-" "-" 0 1297688 7518 460 "10.80.3.231" "curl/7.64.0" "2c71707e-3304-418c-840e-c37256c1ad41" "edition.cnn.com" "151.101.193.67:443" outbound|443||edition.cnn.com 10.80.3.232:38522 10.80.3.232:8080 10.80.3.231:46064 edition.cnn.com -

各種資源的tls設定：

資源 描述
virtualService tls欄位：用於非終結TLS&HTTPS流量的路由規則。通常使用ClientHello訊息中的SNI值進行路由。TLS路由將會應用於埠名為https - tls-的平臺服務，使用HTTPS/TLS協議的非終結閘道器埠(使用passthroughTLS模式)，以及使用HTTPS/TLS協議的serviceEntry埠。注：不關聯virtual service的https-或tls-埠的流量將被視為不透明的TCP流量。
DestinationRule DestinationRule主要對連線上游服務的tls進行配置，包含網格內的閘道器以及網格外的服務
ClientTLSSettings欄位：連線上游的SSL/TLS相關設定
portLevelSettings欄位：按照埠對上游服務進行設定，該欄位包含了ClientTLSSettings欄位
Gateway Gateway主要暴露的服務的tls進行配置，含ingress和egress，前者通常可以使用SIMPLE/MUTUAL模式，後者可以使用SIMPLE/MUTUAL/ISTIO_MUTUAL模式
ServerTLSSettings欄位：控制服務端行為的TLS相關選項集。使用這些選項來控制是否應將所有http請求重定向到https，並使用TLS模式

解除安裝

$ kubectl delete gateway istio-egressgateway
$ kubectl delete serviceentry cnn
$ kubectl delete virtualservice direct-cnn-through-egress-gateway
$ kubectl delete destinationrule originate-tls-for-edition-cnn-com
$ kubectl delete destinationrule egressgateway-for-cnn

使用egress閘道器發起mutual TLS

與前面章節類似，本節描述如何配置egress閘道器來向外部服務發起TLS，不同的是這次要使用mutual TLS(上面用的是SIMPLE模式)。

在本例中首先需要：

  1. 生成client和server證書
  2. 部署支援mutual TLS協議的外部服務
  3. 重新部署egress閘道器，使用mutual TLS證書

然後就是通過egress 閘道器發起TLS。

生成client和server的證書和key

  1. 建立根證書和私鑰，用於簽發服務證書

    $ openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=example Inc./CN=example.com' -keyout example.com.key -out example.com.crt

  2. 為 my-nginx.mesh-external.svc.cluster.local建立證書和私鑰

    $ openssl req -out my-nginx.mesh-external.svc.cluster.local.csr -newkey rsa:2048 -nodes -keyout my-nginx.mesh-external.svc.cluster.local.key -subj "/CN=my-nginx.mesh-external.svc.cluster.local/O=some organization"
$ openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 0 -in my-nginx.mesh-external.svc.cluster.local.csr -out my-nginx.mesh-external.svc.cluster.local.crt

  3. 生成client證書和私鑰

    $ openssl req -out client.example.com.csr -newkey rsa:2048 -nodes -keyout client.example.com.key -subj "/CN=client.example.com/O=client organization"
$ openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 1 -in client.example.com.csr -out client.example.com.crt

部署mutual TLS server

為了模擬一個支援mutual TLS協議的外部服務，需要在kubernetes叢集中部署一個NGINX服務，但該服務位於istio服務網格外，即位於一個沒有啟用istio sidecar代理注入的名稱空間。

  1. 建立一個唯一istio網格外的名稱空間，名為mesh-external，該名稱空間不啟用sidecar自動注入。

    $ kubectl create namespace mesh-external

  2. 建立kubernetes secret，包含服務端的證書和CA證書

    $ kubectl create -n mesh-external secret tls nginx-server-certs --key my-nginx.mesh-external.svc.cluster.local.key --cert my-nginx.mesh-external.svc.cluster.local.crt
$ kubectl create -n mesh-external secret generic nginx-ca-certs --from-file=example.com.crt

  3. 建立NGINX 服務的配置檔案

    $ cat <<\EOF > ./nginx.conf
events {
}

http {
  log_format main '$remote_addr - $remote_user [$time_local]  $status '
  '"$request" $body_bytes_sent "$http_referer" '
  '"$http_user_agent" "$http_x_forwarded_for"';
  access_log /var/log/nginx/access.log main;
  error_log  /var/log/nginx/error.log;

  server {
    listen 443 ssl;

    root /usr/share/nginx/html;
    index index.html;

    server_name my-nginx.mesh-external.svc.cluster.local;
    ssl_certificate /etc/nginx-server-certs/tls.crt;
    ssl_certificate_key /etc/nginx-server-certs/tls.key;
    ssl_client_certificate /etc/nginx-ca-certs/example.com.crt;
    ssl_verify_client on;
  }
}
EOF

  4. 建立一個kubernetes ConfigMap來儲存NGINX服務的配置資訊

    $ kubectl apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  namespace: mesh-external
  labels:
    run: my-nginx
spec:
  ports:
  - port: 443
    protocol: TCP
  selector:
    run: my-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  namespace: mesh-external
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 1
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 443
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx
          readOnly: true
        - name: nginx-server-certs
          mountPath: /etc/nginx-server-certs
          readOnly: true
        - name: nginx-ca-certs
          mountPath: /etc/nginx-ca-certs
          readOnly: true
      volumes:
      - name: nginx-config
        configMap:
          name: nginx-configmap
      - name: nginx-server-certs
        secret:
          secretName: nginx-server-certs
      - name: nginx-ca-certs
        secret:
          secretName: nginx-ca-certs
EOF

使用client證書重新部署egress閘道器

  1. 建立kubernetes secret，包含客戶端證書和CA證書

    $ kubectl create -n istio-system secret tls nginx-client-certs --key client.example.com.key --cert client.example.com.crt
$ kubectl create -n istio-system secret generic nginx-ca-certs --from-file=example.com.crt

  2. 更新istio-egressgateway deployment來掛載建立的secret。建立如下gateway-patch.json檔案來給istio-egressgateway deployment打補丁。

    cat > gateway-patch.json <<EOF
[{
  "op": "add",
  "path": "/spec/template/spec/containers/0/volumeMounts/0",
  "value": {
    "mountPath": "/etc/istio/nginx-client-certs",
    "name": "nginx-client-certs",
    "readOnly": true
  }
},
{
  "op": "add",
  "path": "/spec/template/spec/volumes/0",
  "value": {
  "name": "nginx-client-certs",
    "secret": {
      "secretName": "nginx-client-certs",
      "optional": true
    }
  }
},
{
  "op": "add",
  "path": "/spec/template/spec/containers/0/volumeMounts/1",
  "value": {
    "mountPath": "/etc/istio/nginx-ca-certs",
    "name": "nginx-ca-certs",
    "readOnly": true
  }
},
{
  "op": "add",
  "path": "/spec/template/spec/volumes/1",
  "value": {
  "name": "nginx-ca-certs",
    "secret": {
      "secretName": "nginx-ca-certs",
      "optional": true
    }
  }
}]
EOF

  3. 使用如下命令使補丁生效

    $ kubectl -n istio-system patch --type=json deploy istio-egressgateway -p "$(cat gateway-patch.json)"

  4. 校驗載入到istio-egressgateway pod中的金鑰和證書

    $ kubectl exec -n istio-system "$(kubectl -n istio-system get pods -l istio=egressgateway -o jsonpath='{.items[0].metadata.name}')" -- ls -al /etc/istio/nginx-client-certs /etc/istio/nginx-ca-certs

    tls.crt 和tls.key 應該位於 /etc/istio/nginx-client-certs目錄中，而 ca-chain.cert.pem 位於/etc/istio/nginx-ca-certs目錄中。

配置egress流量的mutual TLS源

  1. 為my-nginx.mesh-external.svc.cluster.local:443建立一個egress Gateway，以及destination rules和virtual service來將流量轉發到egress閘道器上，並通過該egress閘道器轉發給外部服務。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    hosts:
    - my-nginx.mesh-external.svc.cluster.local #暴露給網格內部服務地址，使用ISTIO_MUTUAL進行互動
    tls:
      mode: ISTIO_MUTUAL
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule #處理網格內部pod到閘道器的流量
metadata:
  name: egressgateway-for-nginx
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: nginx
    trafficPolicy:
      loadBalancer:
        simple: ROUND_ROBIN
      portLevelSettings: #連線的上游服務屬性
      - port:
          number: 443
        tls:
          mode: ISTIO_MUTUAL
          sni: my-nginx.mesh-external.svc.cluster.local
EOF

  2. 定義一個VirtualService將流量轉移到egress閘道器

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-nginx-through-egress-gateway
spec:
  hosts:
  - my-nginx.mesh-external.svc.cluster.local
  gateways:
  - istio-egressgateway
  - mesh
  http: #內部流量採用http協議，由閘道器進行mutual tls協商
  - match:
    - gateways:
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: nginx
        port:
          number: 443
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway
      port: 443
    route:
    - destination:
        host: my-nginx.mesh-external.svc.cluster.local #外部服務地址
        port:
          number: 443
      weight: 100
EOF

  3. 新增一個DestinationRule來發起TLS

    $ kubectl apply -n istio-system -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule #處理閘道器到外部服務的流量
metadata:
  name: originate-mtls-for-nginx
spec:
  host: my-nginx.mesh-external.svc.cluster.local
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
    portLevelSettings:
    - port:
        number: 443
      tls:
        mode: MUTUAL #使用MUTUAL模式連線外部服務，證書位於閘道器pod中
        clientCertificate: /etc/istio/nginx-client-certs/tls.crt
        privateKey: /etc/istio/nginx-client-certs/tls.key
        caCertificates: /etc/istio/nginx-ca-certs/example.com.crt
        sni: my-nginx.mesh-external.svc.cluster.local
EOF

  4. 傳送HTTP請求到http://my-nginx.mesh-external.svc.cluster.local:

    $ kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl -s http://my-nginx.mesh-external.svc.cluster.local

    <!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

  5. 校驗istio-egressgateway pod的日誌

    # kubectl logs -l istio=egressgateway -n istio-system | grep 'my-nginx.mesh-external.svc.cluster.local' | grep HTTP
[2020-08-26T08:26:15.054Z] "GET / HTTP/1.1" 200 - "-" "-" 0 612 4 4 "10.80.3.231" "curl/7.64.0" "e8bf12bd-9c39-409e-a837-39afc151fc7e" "my-nginx.mesh-external.svc.cluster.local" "10.80.2.14:443" outbound|443||my-nginx.mesh-external.svc.cluster.local 10.80.2.15:56608 10.80.2.15:8443 10.80.3.231:50962 my-nginx.mesh-external.svc.cluster.local -

解除安裝

$ kubectl delete secret nginx-server-certs nginx-ca-certs -n mesh-external
$ kubectl delete secret istio-egressgateway-certs istio-egressgateway-ca-certs -n istio-system
$ kubectl delete configmap nginx-configmap -n mesh-external
$ kubectl delete service my-nginx -n mesh-external
$ kubectl delete deployment my-nginx -n mesh-external
$ kubectl delete namespace mesh-external
$ kubectl delete gateway istio-egressgateway
$ kubectl delete virtualservice direct-nginx-through-egress-gateway
$ kubectl delete destinationrule -n istio-system originate-mtls-for-nginx
$ kubectl delete destinationrule egressgateway-for-nginx

$ rm example.com.crt example.com.key my-nginx.mesh-external.svc.cluster.local.crt my-nginx.mesh-external.svc.cluster.local.key my-nginx.mesh-external.svc.cluster.local.csr client.example.com.crt client.example.com.csr client.example.com.key

$ rm ./nginx.conf
$ rm ./gateway-patch.json

$ kubectl delete service sleep
$ kubectl delete deployment sleep

帶TLS源的Egress閘道器(SDS)

本節展示如何通過配置一個egress閘道器來為到外部服務的流量發起TLS。使用Secret Discovery Service (SDS)來配置私鑰，服務證書以及根證書(上一節中使用檔案掛載方式來管理證書)。

部署

部署sleep應用，並獲取其Pod名

$ kubectl apply -f samples/sleep/sleep.yaml
$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

egress閘道器使用SDS發起TLS

生成CA和server證書和金鑰

  1. 建立根證書和私鑰來簽署服務的證書

    $ openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=example Inc./CN=example.com' -keyout example.com.key -out example.com.crt

  2. 為 my-nginx.mesh-external.svc.cluster.local建立證書和私鑰

    $ openssl req -out my-nginx.mesh-external.svc.cluster.local.csr -newkey rsa:2048 -nodes -keyout my-nginx.mesh-external.svc.cluster.local.key -subj "/CN=my-nginx.mesh-external.svc.cluster.local/O=some organization"
$ openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 0 -in my-nginx.mesh-external.svc.cluster.local.csr -out my-nginx.mesh-external.svc.cluster.local.crt

部署一個simple 模式的TLS服務

下面的操作與使用檔案掛載相同，部署一個NGINX服務

  1. 建立istio網格外的名稱空間mesh-external

    $ kubectl create namespace mesh-external

  2. 建立kubernetes secret來儲存服務的證書和CA證書

    $ kubectl create -n mesh-external secret tls nginx-server-certs --key my-nginx.mesh-external.svc.cluster.local.key --cert my-nginx.mesh-external.svc.cluster.local.crt
$ kubectl create -n mesh-external secret generic nginx-ca-certs --from-file=example.com.crt

  3. 建立NGINX服務的配置檔案

    $ cat <<\EOF > ./nginx.conf
events {
}

http {
  log_format main '$remote_addr - $remote_user [$time_local]  $status '
  '"$request" $body_bytes_sent "$http_referer" '
  '"$http_user_agent" "$http_x_forwarded_for"';
  access_log /var/log/nginx/access.log main;
  error_log  /var/log/nginx/error.log;

  server {
    listen 443 ssl;

    root /usr/share/nginx/html;
    index index.html;

    server_name my-nginx.mesh-external.svc.cluster.local;
    ssl_certificate /etc/nginx-server-certs/tls.crt;
    ssl_certificate_key /etc/nginx-server-certs/tls.key;
    ssl_client_certificate /etc/nginx-ca-certs/example.com.crt;
    ssl_verify_client off; # simple TLS下server不需要校驗client的證書
  }
}
EOF

  4. 建立一個kubernetes ConfigMap來儲存NGINX服務的配置資訊

    $ kubectl create configmap nginx-configmap -n mesh-external --from-file=nginx.conf=./nginx.conf

  5. 部署NGINX服務

    $ kubectl apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  namespace: mesh-external
  labels:
    run: my-nginx
spec:
  ports:
  - port: 443
    protocol: TCP
  selector:
    run: my-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  namespace: mesh-external
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 1
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 443
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx
          readOnly: true
        - name: nginx-server-certs
          mountPath: /etc/nginx-server-certs
          readOnly: true
        - name: nginx-ca-certs
          mountPath: /etc/nginx-ca-certs
          readOnly: true
      volumes:
      - name: nginx-config
        configMap:
          name: nginx-configmap
      - name: nginx-server-certs
        secret:
          secretName: nginx-server-certs
      - name: nginx-ca-certs
        secret:
          secretName: nginx-ca-certs
EOF

為egress流量發起simple TLS

  1. 建立一個kubernetes Secret來儲存egress網格發起TLS使用的CA證書，由於使用的是SIMPLE模式，因此無需客戶端證書，僅對ca證書實現SDS，後續在閘道器的destinationRule中使用。

    $ kubectl create secret generic client-credential-cacert --from-file=ca.crt=example.com.crt -n istio-system

    注意，Istio-only-CA證書的secret名稱必須以-cacert結尾，並且必須在與部署的Istio相同的名稱空間(預設為Istio-system)中建立該secret。

    secret名稱不應該以istio或prometheus開頭，且secret不能包含token欄位

    下面的配置除最後一個destinationRule外，其餘配置都與上一節相同

  2. 為my-nginx.mesh-external.svc.cluster.local:443建立一個egress Gateway，以及destination rules和virtual service來將流量轉發到egress閘道器上，並通過該egress閘道器轉發給外部服務。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    hosts:
    - my-nginx.mesh-external.svc.cluster.local
    tls:
      mode: ISTIO_MUTUAL
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-nginx
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: nginx
    trafficPolicy:
      loadBalancer:
        simple: ROUND_ROBIN
      portLevelSettings:
      - port:
          number: 443
        tls:
          mode: ISTIO_MUTUAL
          sni: my-nginx.mesh-external.svc.cluster.local
EOF

  3. 定義一個VirtualService將流量轉移到egress閘道器

    kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-nginx-through-egress-gateway
spec:
  hosts:
  - my-nginx.mesh-external.svc.cluster.local
  gateways:
  - istio-egressgateway
  - mesh
  http:
  - match:
    - gateways:
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: nginx
        port:
          number: 443
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway
      port: 443
    route:
    - destination:
        host: my-nginx.mesh-external.svc.cluster.local
        port:
          number: 443
      weight: 100
EOF

  4. 新增一個DestinationRule來發起TLS

    $ kubectl apply -n istio-system -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: originate-tls-for-nginx
spec:
  host: my-nginx.mesh-external.svc.cluster.local
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
    portLevelSettings:
    - port:
        number: 443
      tls:
        mode: SIMPLE
        credentialName: client-credential # 對應前面建立的包含ca證書的secret client-credential-cacert，但此時不帶"-cacert"字尾
        sni: my-nginx.mesh-external.svc.cluster.local #網格外部服務
EOF

  5. 傳送一個HTTP請求到 http://my-nginx.mesh-external.svc.cluster.local:

    $ kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl -s http://my-nginx.mesh-external.svc.cluster.local
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

  6. 檢查istio-egressgateway中的訪問日誌

    # kubectl logs -l istio=egressgateway -n istio-system | grep 'my-nginx.mesh-external.svc.cluster.local' | grep HTTP
[2020-08-26T12:26:09.316Z] "GET / HTTP/1.1" 200 - "-" "-" 0 612 3 3 "10.80.3.231" "curl/7.64.0" "67803676-5617-4e12-a14a-5cef95ea2e87" "my-nginx.mesh-external.svc.cluster.local" "10.80.2.19:443" outbound|443||my-nginx.mesh-external.svc.cluster.local 10.80.2.15:40754 10.80.2.15:8443 10.80.3.231:57626 my-nginx.mesh-external.svc.cluster.local -

解除安裝

$ kubectl delete destinationrule originate-tls-for-nginx -n istio-system
$ kubectl delete virtualservice direct-nginx-through-egress-gateway
$ kubectl delete destinationrule egressgateway-for-nginx
$ kubectl delete gateway istio-egressgateway
$ kubectl delete secret client-credential-cacert -n istio-system
$ kubectl delete service my-nginx -n mesh-external
$ kubectl delete deployment my-nginx -n mesh-external
$ kubectl delete configmap nginx-configmap -n mesh-external
$ kubectl delete secret nginx-server-certs nginx-ca-certs -n mesh-external
$ kubectl delete namespace mesh-external

$ rm example.com.crt example.com.key my-nginx.mesh-external.svc.cluster.local.crt my-nginx.mesh-external.svc.cluster.local.key my-nginx.mesh-external.svc.cluster.local.csr

$ rm ./nginx.conf

egress閘道器使用SDS發起mutual TLS

建立客戶端和服務端證書和金鑰

下面操作跟前面一樣，建立CA和客戶端，服務端證書

$ openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=example Inc./CN=example.com' -keyout example.com.key -out example.com.crt

$ openssl req -out my-nginx.mesh-external.svc.cluster.local.csr -newkey rsa:2048 -nodes -keyout my-nginx.mesh-external.svc.cluster.local.key -subj "/CN=my-nginx.mesh-external.svc.cluster.local/O=some organization"
$ openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 0 -in my-nginx.mesh-external.svc.cluster.local.csr -out my-nginx.mesh-external.svc.cluster.local.crt

$ openssl req -out client.example.com.csr -newkey rsa:2048 -nodes -keyout client.example.com.key -subj "/CN=client.example.com/O=client organization"
$ openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 1 -in client.example.com.csr -out client.example.com.crt

部署一個mutual TLS服務端

下面的配置也跟之前一樣

$ kubectl create namespace mesh-external

$ kubectl create -n mesh-external secret tls nginx-server-certs --key my-nginx.mesh-external.svc.cluster.local.key --cert my-nginx.mesh-external.svc.cluster.local.crt
$ kubectl create -n mesh-external secret generic nginx-ca-certs --from-file=example.com.crt

$ cat <<\EOF > ./nginx.conf
events {
}

http {
  log_format main '$remote_addr - $remote_user [$time_local]  $status '
  '"$request" $body_bytes_sent "$http_referer" '
  '"$http_user_agent" "$http_x_forwarded_for"';
  access_log /var/log/nginx/access.log main;
  error_log  /var/log/nginx/error.log;

  server {
    listen 443 ssl;

    root /usr/share/nginx/html;
    index index.html;

    server_name my-nginx.mesh-external.svc.cluster.local;
    ssl_certificate /etc/nginx-server-certs/tls.crt;
    ssl_certificate_key /etc/nginx-server-certs/tls.key;
    ssl_client_certificate /etc/nginx-ca-certs/example.com.crt;
    ssl_verify_client on; # mutual TLS下的server會校驗client的證書
  }
}
EOF

$ kubectl create configmap nginx-configmap -n mesh-external --from-file=nginx.conf=./nginx.conf

$ kubectl apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  namespace: mesh-external
  labels:
    run: my-nginx
spec:
  ports:
  - port: 443
    protocol: TCP
  selector:
    run: my-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  namespace: mesh-external
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 1
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 443
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx
          readOnly: true
        - name: nginx-server-certs
          mountPath: /etc/nginx-server-certs
          readOnly: true
        - name: nginx-ca-certs
          mountPath: /etc/nginx-ca-certs
          readOnly: true
      volumes:
      - name: nginx-config
        configMap:
          name: nginx-configmap
      - name: nginx-server-certs
        secret:
          secretName: nginx-server-certs
      - name: nginx-ca-certs
        secret:
          secretName: nginx-ca-certs
EOF

配置egress流量使用SDS發起mutual TLS

  1. 建立一個kubernetes secret來儲存客戶端證書和ca證書

    $ kubectl create secret -n istio-system generic client-credential --from-file=tls.key=client.example.com.key \
  --from-file=tls.crt=client.example.com.crt --from-file=ca.crt=example.com.crt

    使用SDS的secret名稱跟上一節的要求一樣，部署到istio所在的名稱空間，且名稱不能以istio和prometheus開頭，不能包含token欄位。

  2. 為my-nginx.mesh-external.svc.cluster.local:443建立Gateway

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    hosts:
    - my-nginx.mesh-external.svc.cluster.local
    tls:
      mode: ISTIO_MUTUAL
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-nginx
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
  - name: nginx
    trafficPolicy:
      loadBalancer:
        simple: ROUND_ROBIN
      portLevelSettings:
      - port:
          number: 443
        tls:
          mode: ISTIO_MUTUAL
          sni: my-nginx.mesh-external.svc.cluster.local
EOF

  3. 建立VirtualService

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-nginx-through-egress-gateway
spec:
  hosts:
  - my-nginx.mesh-external.svc.cluster.local
  gateways:
  - istio-egressgateway
  - mesh
  http:
  - match:
    - gateways:
      - mesh
      port: 80
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: nginx
        port:
          number: 443
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway
      port: 443
    route:
    - destination:
        host: my-nginx.mesh-external.svc.cluster.local
        port:
          number: 443
      weight: 100
EOF

  4. 與前面不同點就在該DestinationRule中的credentialName欄位，包含了前面建立的證書client-credential

    $ kubectl apply -n istio-system -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: originate-mtls-for-nginx
spec:
  host: my-nginx.mesh-external.svc.cluster.local
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
    portLevelSettings:
    - port:
        number: 443
      tls:
        mode: MUTUAL
        credentialName: client-credential # this must match the secret created earlier to hold client certs
        sni: my-nginx.mesh-external.svc.cluster.local
EOF

  5. 傳送請求並校驗egressgateway pod的日誌

    $ kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl -s http://my-nginx.mesh-external.svc.cluster.local
$ kubectl logs -l istio=egressgateway -n istio-system | grep 'my-nginx.mesh-external.svc.cluster.local' | grep HTTP

解除安裝

$ kubectl delete secret nginx-server-certs nginx-ca-certs -n mesh-external
$ kubectl delete secret client-credential -n istio-system
$ kubectl delete configmap nginx-configmap -n mesh-external
$ kubectl delete service my-nginx -n mesh-external
$ kubectl delete deployment my-nginx -n mesh-external
$ kubectl delete namespace mesh-external
$ kubectl delete gateway istio-egressgateway
$ kubectl delete virtualservice direct-nginx-through-egress-gateway
$ kubectl delete destinationrule -n istio-system originate-mtls-for-nginx
$ kubectl delete destinationrule egressgateway-for-nginx

$ rm example.com.crt example.com.key my-nginx.mesh-external.svc.cluster.local.crt my-nginx.mesh-external.svc.cluster.local.key my-nginx.mesh-external.svc.cluster.local.csr client.example.com.crt client.example.com.csr client.example.com.key

$ rm ./nginx.conf
$ rm ./gateway-patch.json

$ kubectl delete service sleep
$ kubectl delete deployment sleep

使用萬用字元主機的egress

上兩節中為閘道器配置了特定的主機名，如 edition.cnn.com。本節將展示如何為egress流量配置位於同域的一組主機，如*.wikipedia.org。

背景說明

假設要在istio上為所有語言的wikipedia.org站點啟用egress流量，每個特定語言的wikipedia.org站點都有其各自的主機名，如en.wikipedia.org 和de.wikipedia.org分別表示英文和德文。此時可能會希望為所有的Wikipedia egress流量配置相同的引數，而不需要為每種語言的站點單獨指定。

原文中用於展示的站點為*.wikipedia.org，但鑑於這類站點在國內無法訪問，故修改為*.baidu.com

部署

部署sleep應用並獲取POD名稱

$ kubectl apply -f samples/sleep/sleep.yaml
$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

配置到萬用字元主機的直接流量

首先，為了簡化場景，建立一個帶萬用字元主機的ServiceEntry，並直接訪問服務。當直接呼叫服務時(不經過egress閘道器)，萬用字元主機的配置與其他主機並沒有什麼不同(只是對同一域中的主機的服務更加方便)。

為*.baidu.com定義一個ServiceEntry和相應的VirtualSevice：

$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: baidu
spec:
  hosts:
  - "*.baidu.com" #萬用字元主機
  ports:
  - number: 443
    name: tls
    protocol: TLS
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: baidu
spec:
  hosts:
  - "*.baidu.com"
  tls:
  - match:
    - port: 443
      sniHosts:
      - "*.baidu.com"
    route:
    - destination:
        host: "*.baidu.com"
        port:
          number: 443
EOF

傳送請求給https://map.baidu.com/和https://fanyi.baidu.com/:

# kubectl exec -it $SOURCE_POD -c sleep -- sh -c 'curl -s https://map.baidu.com/ | grep -o "<title>.*</title>"; curl -s https://fanyi.baidu.com/ | grep -o "<title>.*</title>"'
<title>百度地圖</title>
<title>百度翻譯-200種語言互譯、溝通全世界！</title>

可以不使用VirtualService

解除安裝

$ kubectl delete serviceentry baidu
$ kubectl delete virtualservice baidu

配置到萬用字元主機的egress閘道器流量

通過egress閘道器訪問萬用字元主機的配置取決於萬用字元域集是否由一個公共主機來提供服務。例如*.wikipedia.org，所有指定語言的站點都由*wikipedia.org的某一個服務端提供服務，這樣就可以將流量路由到任何*.wikipedia.org站點對應的IP(包括www.wikipedia.org)。

由於map.baidu.com和fanyi.baidu.com的服務並不是由www.baidu.com對應的某個IP服務的(可以使用nslookup或dig命令檢視)，因此無法用於測試本場景，下面為官網內容

一般情況下，如果一個萬用字元的所有域名不是由一個託管伺服器提供服務的，則需要更復雜的配置。

單個主機伺服器的萬用字元配置

當一個服務端服務所有的萬用字元主機時，對使用egress閘道器訪問萬用字元主機的配置與訪問非萬用字元主機的配置類似。

  1. 為*.wikipedia.org,建立一個egress Gateway，destination rule和一個virtual service，將流量匯入egress閘道器，並通過egress閘道器訪問外部服務

    $  kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-egressgateway
spec:
  selector:
    istio: egressgateway
  servers:
  - port:
      number: 443
      name: tls
      protocol: TLS
    hosts:
    - "*.wikipedia.org"
    tls:
      mode: PASSTHROUGH #由網格內部發起https請求，非終結TLS
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: egressgateway-for-wikipedia
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
    - name: wikipedia
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: direct-wikipedia-through-egress-gateway
spec:
  hosts:
  - "*.wikipedia.org"
  gateways:
  - mesh
  - istio-egressgateway
  tls: #網格內部的TLS流量處理
  - match:
    - gateways:
      - mesh
      port: 443
      sniHosts:
      - "*.wikipedia.org"
    route:
    - destination:
        host: istio-egressgateway.istio-system.svc.cluster.local
        subset: wikipedia
        port:
          number: 443
      weight: 100
  - match:
    - gateways:
      - istio-egressgateway
      port: 443
      sniHosts:
      - "*.wikipedia.org"
    route:
    - destination:
        host: www.wikipedia.org #將流量從網格傳給外部服務
        port:
          number: 443
      weight: 100
EOF

  2. 為目的服務www.wikipedia.com建立ServiceEntry

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: www-wikipedia
spec:
  hosts:
  - www.wikipedia.org
  ports:
  - number: 443
    name: tls
    protocol: TLS
  resolution: DNS
EOF

  3. 傳送請求給https://map.baidu.com/和https://fanyi.baidu.com/:

    $ kubectl exec -it $SOURCE_POD -c sleep -- sh -c 'curl -s https://en.wikipedia.org/wiki/Main_Page | grep -o "<title>.*</title>"; curl -s https://de.wikipedia.org/wiki/Wikipedia:Hauptseite | grep -o "<title>.*</title>"'
<title>Wikipedia, the free encyclopedia</title>
<title>Wikipedia – Die freie Enzyklopädie</title>
解除安裝
$ kubectl delete serviceentry www-wikipedia
$ kubectl delete gateway istio-egressgateway
$ kubectl delete virtualservice direct-wikipedia-through-egress-gateway
$ kubectl delete destinationrule egressgateway-for-wikipedia

任意域的萬用字元配置

上一節中的配置之所以能夠生效，是因為任何一個wikipedia.org服務端都可以服務所有的*.wikipedia.org站點。然有些情況下不是這樣的，例如有可能希望訪問更加通用的域，如.com或.org。

在istio閘道器上配置到任意萬用字元的域會帶來挑戰，上一節中直接將流量傳遞給了 www.wikipedia.org(直接配置到了閘道器上)。受限於Envoy(預設的istio egress閘道器代理)，閘道器並不知道接收到的請求中的任意主機的IP地址。Envoy會將流量路由到預定義的主機，預定義的IP地址或請求中的原始目的IP地址。在閘道器場景下，由於請求會首先被路由到egress閘道器上，因此會丟失請求中的原始目的IP地址，並將目的IP地址替換為閘道器的IP地址，最終會導致基於Envoy的istio閘道器無法路由到沒有進行預配置的任意主機，進而導致無法為任意萬用字元域執行流量控制。

為了給HTTPS和TLS啟用流量控制，需要額外部署一個SNI轉發代理。Envoy會將到萬用字元域的請求路由到SNI轉發代理，然後將請求轉發到SNI中指定的目的地。

使用SNI代理和相關元件的egress閘道器架構如下，由於Envoy無法處理任意萬用字元的主機，因此需要轉發到SNI代理上進行SNI的路由處理。

下面將展示如何重新部署egress閘道器來使用SNI代理，並配置istio通過閘道器路由HTTPS流量到任意萬用字元域。

配置egress閘道器的SNI代理

本節中將在標準的istio Envoy代理之外部署為egress閘道器部署一個SNI代理。本例中使用Nginx作為SNI代理，該SNI代理將會監聽8443埠，然後將流量轉發到443埠。

  1. 為Nginx SNI代理建立配置檔案。注意server下的listen指令為8443，proxy_pass指令使用ssl_preread_server_name，埠443以及將ssl_preread設定為on來啟用SNI reading。

    $ cat <<EOF > ./sni-proxy.conf
user www-data;

events {
}

stream {
  log_format log_stream '\$remote_addr [\$time_local] \$protocol [\$ssl_preread_server_name]'
  '\$status \$bytes_sent \$bytes_received \$session_time';

  access_log /var/log/nginx/access.log log_stream;
  error_log  /var/log/nginx/error.log;

  # tcp forward proxy by SNI
  server {
    resolver 8.8.8.8 ipv6=off;
    listen       127.0.0.1:8443;
    proxy_pass   \$ssl_preread_server_name:443;
    ssl_preread  on;
  }
}
EOF

  2. 建立一個kubernets ConfigMap來儲存Nginx SNI代理的配置

    $ kubectl create configmap egress-sni-proxy-configmap -n istio-system --from-file=nginx.conf=./sni-proxy.conf

  3. 下面命令將生成 istio-egressgateway-with-sni-proxy.yaml

本例因為官方isitoOperator格式有變而無法執行，官方可能需要修改程式碼，參見此issue

配置使用SNI代理的egress閘道器的路由轉發

....

解除安裝
$ kubectl delete serviceentry wikipedia
$ kubectl delete gateway istio-egressgateway-with-sni-proxy
$ kubectl delete virtualservice direct-wikipedia-through-egress-gateway
$ kubectl delete destinationrule egressgateway-for-wikipedia
$ kubectl delete --ignore-not-found=true envoyfilter forward-downstream-sni egress-gateway-sni-verifier

$ kubectl delete serviceentry sni-proxy
$ kubectl delete destinationrule disable-mtls-for-sni-proxy
$ kubectl delete -f ./istio-egressgateway-with-sni-proxy.yaml
$ kubectl delete configmap egress-sni-proxy-configmap -n istio-system

$ rm ./istio-egressgateway-with-sni-proxy.yaml
$ rm ./sni-proxy.conf

解除安裝

$ kubectl delete -f samples/sleep/sleep.yaml

Egress流量的kubernetes服務

kubernetes ExternalName services 和帶Endpoints的kubernetes services 允許為外部服務建立本地DNS別名，該DNS別名的格式與本地服務的DNS表項的格式相同，即 <service name>.<namespace name>.svc.cluster.local。DNS別名為工作負載提供了位置透明性：負載可以通過這種方式呼叫本地和外部服務。如果某個時間需要在叢集中部署外部服務，就可以通過更新該kubernetes service來引用本地版本。工作負載將繼續執行，不需要做任何改變。

本任務將展示istio如何使用這些kubernetes機制來訪問外部服務。不過此時必須使用TLS模式來進行訪問，而不是istio的mutual TLS。因為外部服務不是istio服務網格的一部分，因此不能使用istio mutual TLS，必須根據外部服務的需要以及負載訪問外部服務的方式來設定TLS模式。如果負載發起明文HTTP請求，但外部服務需要TLS，此時可能需要istio發起TLS。如果負載已經使用了TLS，那麼流量已經經過加密，此時就可以禁用istio的mutual TLS。

本節描述如何將istio整合到現有kubernetes配置中

雖然本例使用了HTTP協議，但使用egress流量的kubernetes Services也可以使用其他協議。

部署

  • 部署sleep應用並獲取POD名稱

    $ kubectl apply -f samples/sleep/sleep.yaml
$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

  • 建立一個不使用istio的名稱空間

    $ kubectl create namespace without-istio

  • 在without-istio名稱空間下啟用sleep

    $ kubectl apply -f samples/sleep/sleep.yaml -n without-istio

  • 建立一個環境變數SOURCE_POD_WITHOUT_ISTIO來儲存without-istio名稱空間下的pod名稱

    $ export SOURCE_POD_WITHOUT_ISTIO="$(kubectl get pod -n without-istio -l app=sleep -o jsonpath={.items..metadata.name})"

  • 校驗該pod沒有istio sidecar

    # kubectl get pod "$SOURCE_POD_WITHOUT_ISTIO" -n without-istio
NAME                    READY   STATUS    RESTARTS   AGE
sleep-f8cbf5b76-tbptz   1/1     Running   0          53s

通過kubernetes ExternalName service訪問外部服務

  1. 在default名稱空間中為httpbin.org建立一個kubernetes ExternalName service，將外服服務httpbin.org對映為kubernetes服務my-httpbin，即可以通過訪問my-httpbin.default.svc.cluster.local來訪問my-httpbin。

    $ kubectl apply -f - <<EOF
kind: Service
apiVersion: v1
metadata:
  name: my-httpbin
spec:
  type: ExternalName
  externalName: httpbin.org
  ports:
  - name: http
    protocol: TCP
    port: 80
EOF

  2. 觀察service，可以看到並沒有cluster IP

    # kubectl get svc my-httpbin
NAME         TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
my-httpbin   ExternalName   <none>       httpbin.org   80/TCP    3s

  3. 在源pod(不帶istio sidecar)中通過kubernetes的service主機名訪問 httpbin.org。由於在網格中，因此不需要訪問時禁用istio 的mutual TLS。

    # kubectl exec "$SOURCE_POD_WITHOUT_ISTIO" -n without-istio -c sleep -- curl my-httpbin.default.svc.cluster.local/headers
{
  "headers": {
    "Accept": "*/*",
    "Host": "my-httpbin.default.svc.cluster.local",
    "User-Agent": "curl/7.64.0",
    "X-Amzn-Trace-Id": "Root=1-5f485a71-54548d2e5f8b0dc1002e2ce0"
  }
}

  4. 本例中，使用向 httpbin.org 傳送了未加密的HTTP請求。為了簡單例子，下面禁用了TLS模式，允許向外部服務傳送未加密的流量。在實際使用時，建議配置Egress TLS源，下面相當於將流量重定向到內部服務my-httpbin.default.svc.cluster.local上，而my-httpbin.default.svc.cluster.local映射了外部服務 httpbin.org，這樣就可以通過這種方式通過kubernetes service來訪問外部服務。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: my-httpbin
spec:
  host: my-httpbin.default.svc.cluster.local
  trafficPolicy:
    tls:
      mode: DISABLE
EOF

  5. 在帶istio sidecar的pod中通過kubernetes service主機名訪問httpbin.org，注意isito sidecar新增的首部，如 X-Envoy-Decorator-Operation。同時注意Host首部欄位等於自己的service主機名。

    # kubectl exec "$SOURCE_POD" -c sleep -- curl my-httpbin.default.svc.cluster.local/headers
{
  "headers": {
    "Accept": "*/*",
    "Content-Length": "0",
    "Host": "my-httpbin.default.svc.cluster.local",
    "User-Agent": "curl/7.64.0",
    "X-Amzn-Trace-Id": "Root=1-5f485d05-ac81b19dcee92359b5cae307",
    "X-B3-Sampled": "0",
    "X-B3-Spanid": "bee9babd29c28cec",
    "X-B3-Traceid": "b8260c4ba5390ed0bee9babd29c28cec",
    "X-Envoy-Attempt-Count": "1",
    "X-Envoy-Decorator-Operation": "my-httpbin.default.svc.cluster.local:80/*",
    "X-Envoy-Peer-Metadata": "ChoKCkNMVVNURVJfSUQSDBoKS3ViZXJuZXRlcwo2CgxJTlNUQU5DRV9JUFMSJhokMTAuODAuMi4yNixmZTgwOjozMGI4OmI3ZmY6ZmUxNDpiMjE0Ct4BCgZMQUJFTFMS0wEq0AEKDgoDYXBwEgcaBXNsZWVwChkKDGlzdGlvLmlvL3JldhIJGgdkZWZhdWx0CiAKEXBvZC10ZW1wbGF0ZS1oYXNoEgsaCWY4Y2JmNWI3NgokChlzZWN1cml0eS5pc3Rpby5pby90bHNNb2RlEgcaBWlzdGlvCioKH3NlcnZpY2UuaXN0aW8uaW8vY2Fub25pY2FsLW5hbWUSBxoFc2xlZXAKLwojc2VydmljZS5pc3Rpby5pby9jYW5vbmljYWwtcmV2aXNpb24SCBoGbGF0ZXN0ChoKB01FU0hfSUQSDxoNY2x1c3Rlci5sb2NhbAofCgROQU1FEhcaFXNsZWVwLWY4Y2JmNWI3Ni13bjlyNwoWCglOQU1FU1BBQ0USCRoHZGVmYXVsdApJCgVPV05FUhJAGj5rdWJlcm5ldGVzOi8vYXBpcy9hcHBzL3YxL25hbWVzcGFjZXMvZGVmYXVsdC9kZXBsb3ltZW50cy9zbGVlcAoaCg9TRVJWSUNFX0FDQ09VTlQSBxoFc2xlZXAKGAoNV09SS0xPQURfTkFNRRIHGgVzbGVlcA==",
    "X-Envoy-Peer-Metadata-Id": "sidecar~10.80.2.26~sleep-f8cbf5b76-wn9r7.default~default.svc.cluster.local"
  }
}

解除安裝

$ kubectl delete destinationrule my-httpbin
$ kubectl delete service my-httpbin

使用帶endpoints的kubernetes service訪問一個外部服務

  1. 為map.baidu.com建立一個kubernetes service，不帶selector

    $ kubectl apply -f - <<EOF
kind: Service
apiVersion: v1
metadata:
  name: my-baidu-map
spec:
  ports:
  - protocol: TCP
    port: 443
    name: tls
EOF

  2. 為外部服務手動建立endpoints，IP來自map.baidu.com後端地址。此時可以通過kubernetes service直接訪問外部服務

    # nslookup map.baidu.com
Server:         100.100.2.136
Address:        100.100.2.136#53

Non-authoritative answer:
map.baidu.com   canonical name = map.n.shifen.com.
Name:   map.n.shifen.com
Address: 180.101.49.69

    $ kubectl apply -f - <<EOF
kind: Endpoints
apiVersion: v1
metadata:
  name: my-baidu-map
subsets:
  - addresses:
      - ip: 180.101.49.69
    ports:
      - port: 443
        name: tls
EOF

  3. 觀測上述service，可以通過其cluster IP訪問map.baidu.com

    # oc get svc my-baidu-map
NAME           TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
my-baidu-map   ClusterIP   10.84.20.176   <none>        443/TCP   116s

  4. 從不帶istio sidecar的pod中向map.baidu.com傳送HTTPS請求。注意下面curl在訪問map.baidu.com時使用了--resolve選項

    # kubectl exec "$SOURCE_POD_WITHOUT_ISTIO" -n without-istio -c sleep -- curl -s --resolve map.baidu.com:443:"$(kubectl get service my-baidu-map -o jsonpath='{.spec.clusterIP}')" https://map.baidu.com | grep -o "<title>.*</title>"
<title>百度地圖</title>

  5. 這種情況下，負載會直接向map.baidu.com傳送HTTPS請求，此時可以安全禁用istio的mutual TLS(當然也可以不禁用，此時不需要部署destinationRule)

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: my-baidu-map
spec:
  host: my-baidu-map.default.svc.cluster.local
  trafficPolicy:
    tls:
      mode: DISABLE
EOF

  6. 從帶istio sidecar的pod中訪問map.baidu.com

    # kubectl exec "$SOURCE_POD" -c sleep -- curl -s --resolve map.baidu.com:443:"$(kubectl get service my-baidu-map -o jsonpath='{.spec.clusterIP}')" https://map.baidu.com  | grep -o "<title>.*</title>"
<title>百度地圖</title>

  7. 校驗請求確實是通過cluster IP(10.84.20.176)進行訪問的。

    # kubectl exec "$SOURCE_POD" -c sleep -- curl -v --resolve map.baidu.com:443:"$(kubectl get service my-baidu-map -o jsonpath='{.spec.clusterIP}')" https://map.baidu.com -o /dev/null
* Expire in 0 ms for 6 (transfer 0x562c95903680)
* Added map.baidu.com:443:10.84.20.176 to DNS cache
* Hostname map.baidu.com was found in DNS cache
*   Trying 10.84.20.176...
* TCP_NODELAY set

解除安裝

$ kubectl delete destinationrule my-baidu-map
$ kubectl delete endpoints my-baidu-map
$ kubectl delete service my-baidu-map

解除安裝

$ kubectl delete -f samples/sleep/sleep.yaml
$ kubectl delete -f samples/sleep/sleep.yaml -n without-istio
$ kubectl delete namespace without-istio
$ unset SOURCE_POD SOURCE_POD_WITHOUT_ISTIO

使用外部HTTPS代理

在前面配置Egress閘道器的例子中展示瞭如何通過istio邊界元件Egress閘道器將流量轉發到外部服務中。然而，但是，有些情況下需要外部的、遺留的（非Istio）HTTPS代理來訪問外部服務。例如，公司可能已經部署了一個代理，所有組織中的應用都必須通過該代理來轉發流量。

本例展示如何通過外部代理轉發流量。由於所有的由於都會使用HTTP CONNECT方法來與HTTPS代理建立連線，配置流量到一個外部代理不同於配置流量到外部HTTP和HTTPS服務。

部署

建立sleep應用並獲取POD名稱

$ kubectl apply -f samples/sleep/sleep.yaml
$ export SOURCE_POD=$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})

部署一個HTTPS代理

為了模擬一個遺留的代理，需要在叢集中部署HTTPS代理。為了模擬在叢集外部執行的更真實的代理，需要通過代理的IP地址而不是Kubernetes服務的域名來定位代理的pod。本例使用Squid，但也可以使用其他HTTPS代理來支援HTTP CONNECT。

  1. 為HTTPS代理建立一個名稱空間，不啟用istio sidecar自動注入。使用這種方式來模擬叢集外的代理。

    $ kubectl create namespace external

  2. 建立Squid代理的配置檔案

    $ cat <<EOF > ./proxy.conf
http_port 3128

acl SSL_ports port 443
acl CONNECT method CONNECT

http_access deny CONNECT !SSL_ports
http_access allow localhost manager
http_access deny manager
http_access allow all

coredump_dir /var/spool/squid
EOF

  3. 建立一個kubernetes ConfigMap來儲存代理的配置

    $ kubectl create configmap proxy-configmap -n external --from-file=squid.conf=./proxy.conf

  4. 部署Squid容器。注：openshift可能會因為scc導致許可權錯誤，為方便測試，將容器設定為privileged許可權

    # oc adm policy add-scc-to-user privileged -z default

    $ kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: squid
  namespace: external
spec:
  replicas: 1
  selector:
    matchLabels:
      app: squid
  template:
    metadata:
      labels:
        app: squid
    spec:
      serviceAccount: default
      volumes:
      - name: proxy-config
        configMap:
          name: proxy-configmap
      containers:
      - name: squid
        image: sameersbn/squid:3.5.27
        imagePullPolicy: IfNotPresent
        securityContext:
          privileged: true
        volumeMounts:
        - name: proxy-config
          mountPath: /etc/squid
          readOnly: true
EOF

  5. 在external名稱空間中建立sleep應用來測試到代理的流量(不受istio控制)

    $ kubectl apply -n external -f samples/sleep/sleep.yaml

  6. 獲取代理pod的地址並定義在PROXY_IP環境變數中

    $ export PROXY_IP="$(kubectl get pod -n external -l app=squid -o jsonpath={.items..podIP})"

  7. 定義PROXY_PORT環境變數來儲存代理的埠，即Squid使用的埠3128

    $ export PROXY_PORT=3128

  8. 從external名稱空間中的sleep Pod中通過代理向外部服務傳送請求：

    # kubectl exec "$(kubectl get pod -n external -l app=sleep -o jsonpath={.items..metadata.name})" -n external -- sh -c "HTTPS_PROXY=$PROXY_IP:$PROXY_PORT curl https://map.baidu.com" | grep -o "<title>.*</title>"
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0<title>百度地圖</title>
100  154k    0  154k    0     0   452k      0 --:--:-- --:--:-- --:--:--  452k

  9. 檢查代理的訪問日誌：

    # kubectl exec "$(kubectl get pod -n external -l app=squid -o jsonpath={.items..metadata.name})" -n external -- tail /var/log/squid/access.log
1598596320.477    342 10.80.2.81 TCP_TUNNEL/200 165939 CONNECT map.baidu.com:443 - HIER_DIRECT/180.101.49.69 -

現在，完成了如下兩個於istio無關的任務：

  • 部署了HTTPS 代理
  • 通過代理訪問map.baidu.com

下面將配置啟用istio的pod使用HTTPS代理。

配置流量到外部HTTPS代理

  1. 為HTTPS代理定義一個TCP(非HTTP) Service Entry。雖然應用會使用HTTP CONNECT方法來與HTTPS代理建立連線，但必須為代理配置TCP流量，而非HTTP。一旦建立連線，代理只是充當一個TCP隧道。

    $ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1beta1
kind: ServiceEntry
metadata:
  name: proxy
spec:
  hosts:
  - my-company-proxy.com # ignored
  addresses:
  - $PROXY_IP/32 #hosts欄位的後端IP
  ports:
  - number: $PROXY_PORT
    name: tcp
    protocol: TCP
  location: MESH_EXTERNAL
EOF

  2. 從default名稱空間中的sleep Pod傳送請求，由於該pod帶有sidecar，istio會對流量進行控制

    # kubectl exec "$SOURCE_POD" -c sleep -- sh -c "HTTPS_PROXY=$PROXY_IP:$PROXY_PORT curl https://map.baidu.com" | grep -o "<title>.*</title>"
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0<title>百度地圖</title>
100  154k    0  154k    0     0   439k      0 --:--:-- --:--:-- --:--:--  439k

  3. 檢查istio sidecar 代理的日誌，可以看到對外訪問了my-company-proxy.com

    # kubectl exec "$SOURCE_POD" -c sleep -- sh -c "HTTPS_PROXY=$PROXY_IP:$PROXY_PORT curl https://map.baidu.com" | grep -o "<title>.*</title>"
[2020-08-28T12:38:10.064Z] "- - -" 0 - "-" "-" 898 166076 354 - "-" "-" "-" "-" "10.80.2.87:3128" outbound|3128||my-company-proxy.com 10.80.2.77:36576 10.80.2.87:3128 10.80.2.77:36574 - -

  4. 檢查代理的訪問日誌，可以看到轉發了HTTP CONNECT請求

    # kubectl exec "$(kubectl get pod -n external -l app=squid -o jsonpath={.items..metadata.name})" -n external -- tail /var/log/squid/access.log
1598618290.412    346 10.80.2.77 TCP_TUNNEL/200 166076 CONNECT map.baidu.com:443 - HIER_DIRECT/180.101.49.69 -

過程理解

在本例中完成了如下步驟：

  1. 部署一個HTTPS代理來模擬外部代理
  2. 建立TCP service entry來使istio控制的流量轉發到外部代理

注意不能為需要經過外部代理的外部服務(如map.baidu.com)建立service entry。這是因為從istio的角度看，這些請求僅會發送到外部代理，Istio並不知道外部代理會進一步轉發請求的事實。

解除安裝

$ kubectl delete -f samples/sleep/sleep.yaml
$ kubectl delete -f samples/sleep/sleep.yaml -n external

$ kubectl delete -n external deployment squid
$ kubectl delete -n external configmap proxy-configmap
$ rm ./proxy.conf

$ kubectl delete namespace external

$ kubectl delete serviceentry proxy

相關推薦

Istio的流量管理(實操三)

Istio的流量管理(實操三) 涵蓋官方文件Traffic Management章節中的egress部分。其中有一小部分問題(已在下文標註)待官方解決。

elk之外掛部署 （實操三）

一.外掛安裝 下載head以及node軟體包： elasticsearch-head.tar.gz node-v8.12.0-linux-x64.tar.gz

istio(4)：istio-流量管理-基於請求內容的訪問規則控制

istio(4)：istio-流量管理-基於請求內容的訪問規則控制 將建立的 VirtualService 物件刪除

istio-流量管理-基於不同權重訪問規則控制

istio-流量管理-基於不同權重訪問規則控制 https://www.qikqiak.com/istio-book/traffic-control/2.%E5%9F%BA%E4%BA%8EBookinfo%E8%BF%9B%E8%A1%8Cistio%E6%B5%81%E9%87%8F%E7%AE%A1%E7%90%86%E7%9A%84%E9%85%8D%E7%

istio-流量管理-基於不同版本訪問規則控制

istio-流量管理-基於不同版本訪問規則控制 https://www.qikqiak.com/istio-book/traffic-control/2.%E5%9F%BA%E4%BA%8EBookinfo%E8%BF%9B%E8%A1%8Cistio%E6%B5%81%E9%87%8F%E7%AE%A1%E7%90%86%E7%9A%84%E9%85%8D%E7%

istio-流量管理-服務網格外的流量管理

istio-流量管理-服務網格外的流量管理 這個也一知半解，暫時沒用到，放這吧 為了控制服務網格外的服務的流量訪問，外部的服務必須首先使用一個ServiceEntry物件加入到 istio 的內部 service registry 中，服務網格

技術管理進階——第三個五年，獨立思考與落地實操

原創不易，求分享、求一鍵三連 之前寫了一篇個人經歷介紹： 34歲回顧人生，也怕中年危機！

istio-http流量管理

1. 定義目標與規則istio 服務網格中對服務進行了進一步抽象：可以使用 Pod 標籤對具體的服務程序進行分組；可以定義服務的負載均衡策略；可以為服務指定 TLS 要求；可以為服務設定連線池大小。istio 中，同一服務不同

三維點雲學習（Ⅰ）- C++實操（PCA降維，升維、模型點雲法向量）

技術標籤：三維點雲學習過程c++ 三維點雲學習（Ⅰ）- C++實操 一、VS2013配置PCl1.80庫

如何做好日程管理？實操介紹：不同角色的日程管理方法

在談到這個話題的時候，很多人會疑惑：我需要【日程管理】嗎？【日程管理】跟【任務管理】有什麼區別？

實操 | 從0到1教你用Python來爬取整站天氣網

Scrapy Scrapy是Python開發的一個快速、高層次的螢幕抓取和web抓取框架，用於抓取web站點並從頁面中提取結構化的資料。

SpringBoot後臺許可權管理系統（三)—許可權模組

SpringBoot 後臺許可權框架搭建（一）—後臺框架搭建SpringBoot後臺許可權管理系統（二)—前端工程搭建SpringBoot後臺許可權管理系統（三)—許可權模組SpringBoot後臺許可權管理系統（四)—部署

SpringBoot配置https實操方法

升級 https 記錄 1、去阿里雲購買證書（免費版），並提交稽核資料 購買的證書

mysql建立資料庫,新增使用者,使用者授權實操方法

一、建立mysql資料庫 1.建立資料庫語法 --建立名稱為“testdb”資料庫，並設定編碼集為utf8

mysql允許外網訪問以及修改mysql賬號密碼實操方法

mysql的root賬戶,我在連線時通常用的是localhost或127.0.0.1,公司的測試伺服器上的mysql也是localhost所以我想訪問無法訪問,測試暫停.

mysql刪除關聯表的實操方法

mysql資料庫中，表與表之間進行關聯之後，就不可隨意的進行刪除操作，否則會影響所有關聯表之間的結構，那麼如何安全的刪除關聯表呢，讓我們來了解一下。

MySql刪除表中一行的實操方法

首先你要確定能夠唯一確定你那一行資料的欄位或欄位組合是哪些， DELETE FROM 表名 WHERE 欄位1 = ‘\' and 欄位2 = ‘\' and ...欄位1，...為能夠唯一確定某一行資料的欄位組合，‘\'中填寫你要

mysql通過Navicat分割槽實操講解

mysql分割槽有利於管理非常大的表，mysql分割槽一共有四種類型，range分割槽，list分割槽， hash分割槽，key分割槽，我們通過Navicat 視覺化工具來分割槽

python3-flask-3將資訊寫入日誌的實操方法

使用logging模組，記錄日誌資訊 安裝模組 pip3 install logging 指令碼示例 vim flask_api_logging.py

易語言尋找檔案的實操方法

易語言尋找檔案，這個就相當於是查詢搜尋功能，我們用程式設計的方式，就把這個功能流程化和批量化，節省人力，我給你們操作下。