Men-deploy Ingress ke berbagai cluster

Halaman ini menunjukkan cara men-deploy Ingress yang menyalurkan aplikasi ke beberapa cluster GKE. Untuk mempelajari Multi Cluster Ingress lebih lanjut, lihat Multi Cluster Ingress.

Untuk mengetahui perbandingan mendetail antara Multi Cluster Ingress (MCI), Gateway Multi-cluster (MCG), dan load balancer dengan Grup Endpoint Jaringan Mandiri (LB dan NEG Mandiri, lihat Memilih API load balancing multi-cluster untuk GKE.

Tutorial deployment

Pada tugas berikut, Anda akan men-deploy aplikasi fiktif bernama whereami dan MultiClusterIngress dalam dua cluster. Ingress menyediakan alamat IP virtual (VIP) bersama untuk deployment aplikasi.

Halaman ini didasarkan pada pekerjaan yang dilakukan di Menyiapkan Multi Cluster Ingress, di mana Anda membuat dan mendaftarkan dua cluster. Pastikan Anda memiliki dua cluster yang juga terdaftar ke fleet:

gcloud container clusters list

Outputnya mirip dengan hal berikut ini:

NAME    LOCATION        MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION     NUM_NODES  STATUS
gke-eu  europe-west1-b  1.16.8-gke.9    ***             e2-medium      1.16.8-gke.9     2          RUNNING
gke-us  us-central1-b   1.16.8-gke.9    ***             e2-medium      1.16.6-gke.13 *  2          RUNNING

Membuat Namespace

Karena fleet memiliki properti kesamaan namespace, sebaiknya Anda mengoordinasikan pembuatan dan pengelolaan Namespace di seluruh cluster sehingga Namespace yang identik dimiliki dan dikelola oleh grup yang sama. Anda dapat membuat Namespace per tim, per lingkungan, per aplikasi, atau per komponen aplikasi. Namespace dapat sangat terperinci jika dibutuhkan, selama ns1 Namespace di satu cluster memiliki makna dan penggunaan yang sama dengan ns1 di cluster yang lain.

Dalam contoh ini, Anda akan membuat Namespace whereami untuk setiap aplikasi di setiap cluster.

  1. Buat file bernama namespace.yaml dengan isi sebagai berikut:

    apiVersion: v1
kind: Namespace
metadata:
  name: whereami

  2. Beralihlah ke konteks gke-us:

    kubectl config use-context gke-us

  3. Buat Namespace:

    kubectl apply -f namespace.yaml

  4. Beralihlah ke konteks gke-eu:

    kubectl config use-context gke-eu

  5. Buat Namespace:

    kubectl apply -f namespace.yaml

    Outputnya mirip dengan hal berikut ini:

    namespace/whereami created

Men-deploy aplikasi

  1. Buat file bernama deploy.yaml dengan isi sebagai berikut:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: whereami-deployment
  namespace: whereami
  labels:
    app: whereami
spec:
  selector:
    matchLabels:
      app: whereami
  template:
    metadata:
      labels:
        app: whereami
    spec:
      containers:
      - name: frontend
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1.2.20
        ports:
        - containerPort: 8080

  2. Beralihlah ke konteks gke-us:

    kubectl config use-context gke-us

  3. Deploy aplikasi whereami:

    kubectl apply -f deploy.yaml

  4. Beralihlah ke konteks gke-eu:

    kubectl config use-context gke-eu

  5. Deploy aplikasi whereami:

    kubectl apply -f deploy.yaml

  6. Verifikasi bahwa aplikasi whereami telah berhasil di-deploy di setiap cluster:

    kubectl get deployment --namespace whereami

    Outputnya akan mirip dengan yang berikut ini di kedua cluster:

    NAME           READY   UP-TO-DATE   AVAILABLE   AGE
whereami-deployment   1/1     1            1           12m

Men-deploy melalui cluster konfigurasi

Setelah aplikasi di-deploy ke gke-us dan gke-eu, Anda akan men-deploy load balancer dengan men-deploy resource MultiClusterIngress dan MultiClusterService di cluster konfigurasi. Ini adalah padanan multi-cluster resource Ingress dan Service.

Dalam panduan penyiapan, Anda telah mengonfigurasi cluster gke-us sebagai cluster konfigurasi. Cluster konfigurasi digunakan untuk men-deploy dan mengonfigurasi Ingress di semua cluster.

  1. Tetapkan konteks ke cluster konfigurasi.

    kubectl config use-context gke-us

MultiClusterService

  1. Buat file bernama mcs.yaml dengan isi sebagai berikut:

    apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: whereami-mcs
  namespace: whereami
spec:
  template:
    spec:
      selector:
        app: whereami
      ports:
      - name: web
        protocol: TCP
        port: 8080
        targetPort: 8080

  2. Deploy resource MultiClusterService yang cocok dengan aplikasi whereami:

    kubectl apply -f mcs.yaml

  3. Verifikasi bahwa resource whereami-mcs telah berhasil di-deploy di cluster konfigurasi:

    kubectl get mcs -n whereami

    Outputnya mirip dengan hal berikut ini:

    NAME       AGE
whereami-mcs   9m26s

    MultiClusterService ini membuat Service headless turunan di setiap cluster yang cocok dengan Pod dengan app: whereami. Anda dapat melihat bahwa sudah ada Service di cluster gke-us kubectl get service -n whereami.

    Outputnya mirip dengan hal berikut ini:

    NAME                                TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)          AGE
mci-whereami-mcs-svc-lgq966x5mxwwvvum   ClusterIP   None          <none>        8080/TCP         4m59s

Service headless yang serupa juga akan ada di gke-eu. Service lokal ini digunakan untuk memilih endpoint Pod secara dinamis guna memprogram load balancer Ingress global dengan backend.

MultiClusterIngress

  1. Buat file bernama mci.yaml dengan isi sebagai berikut:

    apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: whereami-ingress
  namespace: whereami
spec:
  template:
    spec:
      backend:
        serviceName: whereami-mcs
        servicePort: 8080

    Perhatikan bahwa konfigurasi ini akan merutekan semua traffic ke MultiClusterService bernama whereami-mcs yang ada di namespace whereami.

  2. Deploy resource MultiClusterIngress yang mereferensikan whereami-mcs sebagai backend:

    kubectl apply -f mci.yaml

    Outputnya mirip dengan hal berikut ini:

    multiclusteringress.networking.gke.io/whereami-ingress created

    Perlu diperhatikan bahwa MultiClusterIngress memiliki skema yang sama dengan Ingress Kubernetes. Semantik resource Ingress juga sama kecuali untuk kolom backend.serviceName.

Kolom backend.serviceName di MultiClusterIngress mereferensikan MultiClusterService di Fleet API, bukan Service di cluster Kubernetes. Ini berarti semua setelan untuk setelan Ingress, seperti TLS termination, dapat dikonfigurasi dengan cara yang sama.

Memvalidasi status deployment yang berhasil

Deployment Load Balancer Google Cloud mungkin memerlukan waktu beberapa menit untuk load balancer baru. Pembaruan load balancer yang ada akan selesai lebih cepat karena resource baru tidak perlu di-deploy. Resource MultiClusterIngress menjelaskan resource Compute Engine pokok yang telah dibuat atas nama MultiClusterIngress.

  1. Verifikasi bahwa deployment telah berhasil:

    kubectl describe mci whereami-ingress -n whereami

    Outputnya mirip dengan hal berikut ini:

    Name:         whereami-ingress
Namespace:    whereami
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"networking.gke.io/v1","kind":"MultiClusterIngress","metadata":{"annotations":{},"name":"whereami-ingress","namespace":"whe...
API Version:  networking.gke.io/v1
Kind:         MultiClusterIngress
Metadata:
  Creation Timestamp:  2020-04-10T23:35:10Z
  Finalizers:
    mci.finalizer.networking.gke.io
  Generation:        2
  Resource Version:  26458887
  Self Link:         /apis/networking.gke.io/v1/namespaces/whereami/multiclusteringresses/whereami-ingress
  UID:               62bec0a4-8a08-4cd8-86b2-d60bc2bda63d
Spec:
  Template:
    Spec:
      Backend:
        Service Name:  whereami-mcs
        Service Port:  8080
Status:
  Cloud Resources:
    Backend Services:
      mci-8se3df-8080-whereami-whereami-mcs
    Firewalls:
      mci-8se3df-default-l7
    Forwarding Rules:
      mci-8se3df-fw-whereami-whereami-ingress
    Health Checks:
      mci-8se3df-8080-whereami-whereami-mcs
    Network Endpoint Groups:
      zones/europe-west1-b/networkEndpointGroups/k8s1-e4adffe6-whereami-mci-whereami-mcs-svc-lgq966x5m-808-88670678
      zones/us-central1-b/networkEndpointGroups/k8s1-a6b112b6-whereami-mci-whereami-mcs-svc-lgq966x5m-808-609ab6c6
    Target Proxies:
      mci-8se3df-whereami-whereami-ingress
    URL Map:  mci-8se3df-whereami-whereami-ingress
  VIP:        34.98.102.37
Events:
  Type    Reason  Age                    From                              Message
  ----    ------  ----                   ----                              -------
  Normal  ADD     3m35s                  multi-cluster-ingress-controller  whereami/whereami-ingress
  Normal  UPDATE  3m10s (x2 over 3m34s)  multi-cluster-ingress-controller  whereami/whereami-ingress

    Ada beberapa kolom yang menunjukkan status deployment Ingress ini:

    • Events adalah tempat pertama yang harus dilihat. Error yang terjadi akan selalu dicantumkan di sini.

    • Cloud Resource menampilkan daftar resource Compute Engine seperti aturan penerusan, layanan backend, dan aturan firewall yang telah dibuat oleh pengontrol Multi Cluster Ingress. Jika tidak tercantum, berarti resource tersebut belum dibuat. Anda dapat memeriksa resource Compute Engine satu per satu di konsol atau dengan perintah gcloud untuk mendapatkan statusnya.

    • VIP menampilkan daftar alamat IP jika sudah ada VIP yang dialokasikan. Perhatikan bahwa load balancer mungkin belum memproses traffic meskipun VIP sudah ada. Jika Anda tidak melihat VIP setelah beberapa menit, atau jika load balancer tidak menampilkan respons 200 dalam waktu 10 menit, lihat Pemecahan masalah dan operasi.

    Jika peristiwa output-nya adalah Normal, deployment MultiClusterIngress kemungkinan berhasil, tetapi satu-satunya cara untuk memastikan bahwa jalur traffic lengkap tersebut berfungsi adalah dengan mengujinya.

  2. Validasi bahwa aplikasi berfungsi di VIP dengan endpoint /ping:

    curl INGRESS_VIP/ping

    Ganti INGRESS_VIP dengan alamat IP virtual (VIP).

    Outputnya mirip dengan hal berikut ini:

    {
"cluster_name": "gke-us",
"host_header": "34.120.175.141",
"pod_name": "whereami-deployment-954cbf78-mtlpf",
"pod_name_emoji": "😎",
"project_id": "my-project",
"timestamp": "2021-11-29T17:01:59",
"zone": "us-central1-b"
}

    Output ini harus menunjukkan region dan backend aplikasi.

  3. Anda juga dapat membuka URL http://INGRESS_VIP di browser untuk melihat versi grafis aplikasi yang menunjukkan region dari mana aplikasi tersebut disalurkan.

    Cluster tujuan penerusan traffic bergantung pada lokasi Anda. GCLB dirancang untuk meneruskan traffic klien ke backend terdekat yang tersedia dan memiliki kapasitas.

Spesifikasi resource

Spesifikasi MultiClusterService

Definisi MultiClusterService terdiri atas dua bagian:

  1. Bagian template menentukan Service yang akan dibuat di cluster Kubernetes. Perhatikan bahwa meskipun bagian template berisi kolom yang didukung dalam Service standar, hanya ada dua kolom yang didukung di MultiClusterService: selector dan ports. Kolom lainnya akan diabaikan.

  2. Bagian clusters bersifat opsional dan menentukan cluster mana yang menerima traffic dan properti load balancing untuk setiap cluster. Jika tidak ada bagian clusters yang ditentukan atau jika tidak ada cluster yang tercantum, semua cluster akan digunakan secara default.

Manifes berikut menjelaskan MultiClusterService standar:

apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: NAME
  namespace: NAMESPACE
spec:
  template:
    spec:
      selector:
        app: POD_LABEL
      ports:
      - name: web
        protocol: TCP
        port: PORT
        targetPort: TARGET_PORT

Ganti kode berikut:

  • NAME: nama MultiClusterService. Nama ini direferensikan oleh kolom serviceName dalam resource MultiClusterIngress.
  • NAMESPACE: Namespace Kubernetes tempat MultiClusterService di-deploy. Nama ini harus berada di Namespace yang sama dengan MultiClusterIngress dan Pod di semua cluster dalam fleet.
  • POD_LABEL: label yang menentukan pod mana yang dipilih sebagai backend untuk MultiClusterService ini di semua cluster dalam fleet.
  • PORT: harus cocok dengan port yang direferensikan oleh MultiClusterIngress yang mereferensikan MultiClusterService ini.
  • TARGET_PORT: port yang digunakan untuk mengirim traffic ke Pod dari GCLB. NEG dibuat di setiap cluster dengan port ini sebagai port penyalurannya.

Spesifikasi MultiClusterIngress

mci.yaml berikut menjelaskan frontend load balancer:

apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: NAME
  namespace: NAMESPACE
spec:
  template:
    spec:
      backend:
       serviceName: DEFAULT_SERVICE
       servicePort: PORT
      rules:
        - host: HOST_HEADER
          http:
            paths:
            - path: PATH
              backend:
                serviceName: SERVICE
                servicePort: PORT

Ganti kode berikut:

  • NAME: nama resource MultiClusterIngress.
  • NAMESPACE: Namespace Kubernetes tempat MultiClusterIngress di-deploy. Nama ini harus berada di Namespace yang sama dengan MultiClusterService dan Pod di semua cluster dalam fleet.
  • DEFAULT_SERVICE: bertindak sebagai backend default untuk semua traffic yang tidak cocok dengan aturan host atau jalur mana pun. Kolom ini harus ada dan backend default harus ditentukan di MultiClusterIngress meskipun ada kecocokan host atau jalur lainnya yang dikonfigurasi.
  • PORT: semua nomor port yang valid. Kolom ini harus cocok dengan kolom port di resource MultiClusterService.
  • HOST_HEADER: mencocokkan traffic menurut kolom header host HTTP. Kolom host bersifat opsional.
  • PATH: mencocokkan traffic menurut jalur URL HTTP. Kolom path bersifat opsional.
  • SERVICE: nama MultiClusterService yang di-deploy di cluster konfigurasi dan Namespace yang sama dengan MultiClusterIngress ini.

Fitur Multi Cluster Ingress

Bagian ini berisi penjelasan tentang cara mengonfigurasi fitur Multi Cluster Ingress lainya.

Pemilihan cluster

Secara default, Service yang diturunkan dari Multi Cluster Ingress dijadwalkan di setiap cluster anggota. Namun, Anda mungkin ingin menerapkan aturan ingress ke cluster tertentu. Beberapa kasus penggunaan mencakup:

  • Menerapkan Multi Cluster Ingress ke semua cluster kecuali cluster konfigurasi untuk penyekatan cluster konfigurasi.
  • Memigrasikan workload antar-cluster dalam mode blue-green.
  • Melakukan perutean ke backend aplikasi yang hanya ada di sebagian cluster.
  • Menggunakan satu VIP L7 untuk perutean host atau jalur ke backend yang berada di cluster berbeda.

Pemilihan cluster memungkinkan Anda memilih cluster berdasarkan region atau nama dalam objek MultiClusterService. Hal ini mengontrol cluster mana yang dituju MultiClusterIngress Anda dan di mana Service turunan dijadwalkan. Cluster dalam fleet dan region yang sama tidak boleh memiliki nama yang sama agar cluster dapat direferensikan secara unik.

  1. Buka mcs.yaml

    apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: whereami-mcs
  namespace: whereami
spec:
  template:
    spec:
      selector:
        app: whereami
      ports:
      - name: web
        protocol: TCP
        port: 8080
        targetPort: 8080

    Spesifikasi ini membuat Layanan Turunan di semua cluster, yang merupakan perilaku default.

  2. Tambahkan baris berikut di bagian cluster:

    apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: whereami-mcs
  namespace: whereami
spec:
  template:
    spec:
      selector:
        app: whereami
      ports:
      - name: web
        protocol: TCP
        port: 8080
        targetPort: 8080
  clusters:
  - link: "us-central1-b/gke-us"
  - link: "europe-west1-b/gke-eu"

    Contoh ini membuat resource Service turunan hanya di cluster gke-us dan gke-eu. Anda harus memilih cluster untuk menerapkan aturan ingress secara selektif. Jika bagian "cluster" dalam MultiClusterService tidak ditentukan atau jika tidak ada cluster yang tercantum, cluster "all" (default) akan digunakan.

Dukungan HTTPS

Secret Kubernetes mendukung HTTPS. Sebelum mengaktifkan dukungan HTTPS, Anda harus membuat alamat IP statis. IP statis ini memungkinkan HTTP dan HTTPS berbagi alamat IP yang sama. Untuk informasi selengkapnya, lihat Membuat IP statis.

Setelah membuat alamat IP statis, Anda dapat membuat Secret.

  1. Buat Secret:

    kubectl -n whereami create secret tls SECRET_NAME --key PATH_TO_KEYFILE --cert PATH_TO_CERTFILE

    Ganti kode berikut:

    • SECRET_NAME dengan nama Secret Anda.
    • PATH_TO_KEYFILE dengan jalur ke file kunci TLS.
    • PATH_TO_CERTFILE dengan jalur ke file sertifikat TLS.

  2. Perbarui file mci.yaml dengan nama Secret:

    apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: whereami-ingress
  namespace: whereami
  annotations:
    networking.gke.io/static-ip: STATIC_IP_ADDRESS
spec:
  template:
    spec:
      backend:
        serviceName: whereami-mcs
        servicePort: 8080
      tls:
      - secretName: SECRET_NAME

    Ganti SECRET_NAME dengan nama Secret Anda. STATIC_IP_ADDRESS adalah alamat IP atau URL lengkap dari alamat yang Anda alokasikan di bagian Membuat IP statis.

  3. Deploy ulang resource MultiClusterIngress:

    kubectl apply -f mci.yaml

    Outputnya mirip dengan hal berikut ini:

    multiclusteringress.networking.gke.io/whereami-ingress configured

Dukungan BackendConfig

CRD BackendConfig berikut memungkinkan Anda menyesuaikan setelan pada resource BackendService Compute Engine:

apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  name: whereami-health-check-cfg
  namespace: whereami
spec:
  healthCheck:
    checkIntervalSec: [int]
    timeoutSec: [int]
    healthyThreshold: [int]
    unhealthyThreshold: [int]
    type: [HTTP | HTTPS | HTTP2 | TCP]
    port: [int]
    requestPath: [string]
  timeoutSec: [int]
  connectionDraining:
    drainingTimeoutSec: [int]
  sessionAffinity:
    affinityType: [CLIENT_IP | CLIENT_IP_PORT_PROTO | CLIENT_IP_PROTO | GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | NONE]
    affinityCookieTtlSec: [int]
  cdn:
    enabled: [bool]
    cachePolicy:
      includeHost: [bool]
      includeQueryString: [bool]
      includeProtocol: [bool]
      queryStringBlacklist: [string list]
      queryStringWhitelist: [string list]
  securityPolicy:
    name: ca-how-to-security-policy
  logging:
    enable: [bool]
    sampleRate: [float]
  iap:
    enabled: [bool]
    oauthclientCredentials:
      secretName: [string]

Untuk menggunakannya, lampirkan BackendConfig pada resource MultiClusterService menggunakan anotasi:

apiVersion: networking.gke.io/v1
kind: MultiClusterService
metadata:
  name: whereami-mcs
  namespace: whereami
  annotations:
    cloud.google.com/backend-config: '{"ports": {"8080":"whereami-health-check-cfg"}}'
spec:
 template:
   spec:
     selector:
       app: whereami
     ports:
     - name: web
       protocol: TCP
       port: 8080
       targetPort: 8080

Untuk informasi selengkapnya tentang semantik BackendConfig, lihat Mengaitkan port layanan dengan BackendConfig.

Dukungan gRPC

Mengonfigurasi aplikasi gRPC di Multi Cluster Ingress memerlukan penyiapan yang sangat spesifik. Berikut beberapa tips untuk memastikan load balancer Anda dikonfigurasi dengan benar:

  1. Pastikan traffic dari load balancer ke aplikasi Anda adalah HTTP/2. Gunakan protokol aplikasi untuk mengonfigurasinya.
  2. Pastikan aplikasi Anda dikonfigurasi dengan benar untuk SSL karena ini merupakan syarat HTTP/2. Perhatikan bahwa Anda boleh menggunakan sertifikat yang ditandatangani sendiri.
  3. Anda harus menonaktifkan mTLS di aplikasi karena mTLS tidak didukung untuk load balancer eksternal L7.

Siklus proses resource

Perubahan konfigurasi

Resource MultiClusterIngress dan MultiClusterService berperilaku sebagai objek Kubernetes standar, sehingga perubahan pada objek akan tercermin secara asinkron dalam sistem. Perubahan apa pun yang menghasilkan konfigurasi tidak valid akan menyebabkan objek Google Cloud yang terkait tetap tidak berubah dan menimbulkan error dalam aliran peristiwa objek. Error yang terkait dengan konfigurasi akan dilaporkan sebagai peristiwa.

Mengelola resource Kubernetes

Jika objek Ingress dihapus, load balancer HTTP(S) akan terhapus sehingga traffic tidak lagi diteruskan ke MultiClusterService yang ditentukan.

Menghapus MultiClusterService akan menghapus Service turunan terkaitnya di setiap cluster.

Mengelola cluster

Set cluster yang ditarget oleh load balancer dapat diubah dengan menambahkan cluster ke, atau menghapus cluster dari, fleet.

Misalnya, untuk menghapus cluster gke-eu sebagai backend bagi sebuah ingress, jalankan:

gcloud container fleet memberships unregister CLUSTER_NAME \
  --gke-uri=URI

Ganti kode berikut:

  • CLUSTER_NAME: nama cluster Anda.
  • URI: URI cluster GKE.

Untuk menambahkan cluster di Eropa, jalankan:

gcloud container fleet memberships register europe-cluster \
  --context=europe-cluster --enable-workload-identity

Anda dapat mempelajari opsi pendaftaran cluster lebih lanjut di Mendaftarkan cluster GKE.

Perlu diperhatikan bahwa pendaftaran atau pembatalan pendaftaran cluster akan mengubah statusnya sebagai backend untuk semua Ingress. Membatalkan pendaftaran cluster gke-eu akan menghapusnya sebagai backend yang tersedia untuk semua Ingress yang Anda buat. Hal sebaliknya berlaku untuk pendaftaran cluster baru.

Menonaktifkan Multi Cluster Ingress

Sebelum menonaktifkan Multi Cluster Ingress, Anda harus memastikan bahwa Anda telah menghapus resource MultiClusterIngress dan MultiClusterService, serta memastikan semua resource jaringan yang terkait telah dihapus.

Kemudian, untuk menonaktifkan Multi Cluster Ingress, gunakan perintah berikut:

gcloud container fleet ingress disable

Jika Anda tidak menghapus resource MultiClusterIngress dan MultiClusterService sebelum menonaktifkan Multi Cluster Ingress, Anda mungkin mengalami error yang serupa dengan berikut:

Feature has associated resources that should be cleaned up before deletion.

Jika ingin menonaktifkan Multi Cluster Ingress secara paksa, gunakan perintah berikut:

gcloud container fleet ingress disable --force

Anotasi

Anotasi berikut didukung pada resource MultiClusterIngress dan MultiClusterService.

Anotasi MultiClusterIngress

Anotasi Deskripsi
networking.gke.io/frontend-config Mereferensikan resource FrontendConfig dalam Namespace yang sama dengan resource MultiClusterIngress.
networking.gke.io/static-ip Merujuk ke alamat IP literal dari IP statis global.
networking.gke.io/pre-shared-certs Merujuk ke resource SSLCertificate global.

Anotasi MultiClusterService

Anotasi Deskripsi
networking.gke.io/app-protocols Gunakan anotasi ini untuk menetapkan protokol komunikasi antara load balancer dan aplikasi. Protokol yang mungkin adalah HTTP, HTTPS, dan HTTP/2. Lihat HTTPS antara load balancer dan aplikasi serta HTTP/2 untuk load balancing dengan Ingress.
cloud.google.com/backend-config Gunakan anotasi ini untuk mengonfigurasi layanan backend yang terkait dengan servicePort. Untuk informasi selengkapnya, lihat Konfigurasi Ingress.

Kebijakan SSL dan Pengalihan HTTPS

Anda dapat menggunakan resource FrontendConfig untuk mengonfigurasi kebijakan SSL dan pengalihan HTTPS. Dengan kebijakan SSL, Anda dapat menentukan cipher suite dan versi TLS yang diterima oleh load balancer. Pengalihan HTTPS memungkinkan Anda menerapkan pengalihan dari HTTP atau port 80 ke HTTPS atau port 443. Langkah-langkah berikut akan mengonfigurasi kebijakan SSL dan pengalihan HTTPS secara bersamaan. Perlu diperhatikan bahwa keduanya juga dapat dikonfigurasi secara terpisah.

  1. Buat kebijakan SSL yang akan menolak permintaan yang menggunakan TLS sebelum versi v1.2.

    gcloud compute ssl-policies create tls-12-policy \
 --profile MODERN \
 --min-tls-version 1.2 \
 --project=PROJECT_ID

    Ganti PROJECT_ID dengan project ID tempat cluster GKE Anda berjalan.

  2. Lihat kebijakan Anda untuk memastikan bahwa kebijakan tersebut telah dibuat.

    gcloud compute ssl-policies list --project=PROJECT_ID

    Outputnya mirip dengan hal berikut ini:

    NAME           PROFILE  MIN_TLS_VERSION
tls-12-policy  MODERN   TLS_1_2

  3. Buat sertifikat untuk foo.example.com seperti dalam contoh. Setelah Anda memiliki key.pem dan cert.pem, simpan kredensial ini sebagai Secret yang akan direferensikan oleh resource MultiClusterIngress.

    kubectl -n whereami create secret tls SECRET_NAME --key key.pem --cert cert.pem

  4. Simpan resource FrontendConfig berikut sebagai frontendconfig.yaml. Lihat Mengonfigurasi resource FrontendConfig untuk mengetahui informasi selengkapnya tentang kolom yang didukung dalam FrontendConfig.

    apiVersion: networking.gke.io/v1beta1
kind: FrontendConfig
metadata:
  name: frontend-redirect-tls-policy
  namespace: whereami
spec:
  sslPolicy: tls-12-policy
  redirectToHttps:
    enabled: true

    FrontendConfig ini akan mengaktifkan pengalihan HTTPS dan kebijakan SSL yang memberlakukan TLS minimum versi 1.2.

  5. Deploy frontendconfig.yaml ke cluster konfigurasi Anda.

    kubectl apply -f frontendconfig.yaml --context MCI_CONFIG_CLUSTER

    Ganti MCI_CONFIG_CLUSTER dengan nama cluster konfigurasi Anda.

  6. Simpan MultiClusterIngress berikut sebagai mci-frontendconfig.yaml.

    apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: foo-ingress
  namespace: whereami
  annotations:
    networking.gke.io/frontend-config: frontend-redirect-tls-policy
    networking.gke.io/static-ip: STATIC_IP_ADDRESS
spec:
  template:
    spec:
      backend:
        serviceName: default-backend
        servicePort: 8080
      rules:
      - host: foo.example.com
        http:
          paths:
            - backend:
                serviceName: whereami-mcs
                servicePort: 8080
      tls:
      - secretName: SECRET_NAME
    • Ganti STATIC_IP_ADDRESS dengan alamat IP global statis yang telah Anda sediakan.
    • Ganti SECRET_NAME dengan Secret tempat sertifikat foo.example.com Anda disimpan.

    Ada dua persyaratan saat mengaktifkan pengalihan HTTPS:

    • TLS harus diaktifkan, entah itu melalui kolom spec.tls atau melalui anotasi sertifikat yang dibagikan sebelumnya networking.gke.io/pre-shared-certs. MultiClusterIngress tidak akan di-deploy jika pengalihan HTTPS diaktifkan, tetapi HTTPS tidak.
    • IP statis harus direferensikan melalui anotasi networking.gke.io/static-ip. IP statis harus ada saat mengaktifkan HTTPS di MultiClusterIngress.

  7. Deploy MultiClusterIngress ke cluster konfigurasi Anda.

    kubectl apply -f mci-frontendconfig.yaml --context MCI_CONFIG_CLUSTER

  8. Tunggu satu atau dua menit, lalu periksa foo-ingress.

    kubectl describe mci foo-ingress --context MCI_CONFIG_CLUSTER

    Output yang berhasil akan terlihat seperti berikut:

    • Status Cloud Resources diisi dengan nama resource
    • Kolom VIP diisi dengan alamat IP load balancer
    Name:         foobar-ingress
Namespace:    whereami

...

Status:
  Cloud Resources:
    Backend Services:
      mci-otn9zt-8080-whereami-bar
      mci-otn9zt-8080-whereami-default-backend
      mci-otn9zt-8080-whereami-foo
    Firewalls:
      mci-otn9zt-default-l7
    Forwarding Rules:
      mci-otn9zt-fw-whereami-foobar-ingress
      mci-otn9zt-fws-whereami-foobar-ingress
    Health Checks:
      mci-otn9zt-8080-whereami-bar
      mci-otn9zt-8080-whereami-default-backend
      mci-otn9zt-8080-whereami-foo
    Network Endpoint Groups:
      zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluste-mci-default-backend-svc--80-9e362e3d
      zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluster--mci-bar-svc-067a3lzs8-808-89846515
      zones/europe-west1-b/networkEndpointGroups/k8s1-1869d397-multi-cluster--mci-foo-svc-820zw3izx-808-8bbcb1de
      zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluste-mci-default-backend-svc--80-a528cc75
      zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluster--mci-bar-svc-067a3lzs8-808-36281739
      zones/us-central1-b/networkEndpointGroups/k8s1-a63e24a6-multi-cluster--mci-foo-svc-820zw3izx-808-ac733579
    Target Proxies:
      mci-otn9zt-whereami-foobar-ingress
      mci-otn9zt-whereami-foobar-ingress
    URL Map:  mci-otn9zt-rm-whereami-foobar-ingress
  VIP:        34.149.29.76
Events:
  Type     Reason  Age                From                              Message
  ----     ------  ----               ----                              -------
  Normal   UPDATE  38m (x5 over 62m)  multi-cluster-ingress-controller  whereami/foobar-ingress

  9. Pastikan pengalihan HTTPS berfungsi dengan benar dengan mengirim permintaan HTTP melalui curl.

    curl VIP

    Ganti VIP dengan alamat IP MultiClusterIngress.

    Output-nya akan menunjukkan bahwa permintaan dialihkan ke port HTTPS, yang berarti bahwa pengalihan tersebut berfungsi dengan benar.

  10. Pastikan kebijakan TLS berfungsi dengan benar dengan mengirim permintaan HTTPS menggunakan TLS versi 1.1. Karena DNS tidak dikonfigurasi untuk domain ini, gunakan opsi --resolve untuk memberi tahu curl agar me-resolve alamat IP secara langsung.

    curl https://foo.example.com --resolve foo.example.com:443:VIP --cacert CERT_FILE -v

    Langkah ini memerlukan file PEM sertifikat yang digunakan untuk mengamankan MultiClusterIngress. Output yang berhasil akan terlihat seperti berikut:

    ...
* SSL connection using TLSv1.2 / ECDHE-RSA-CHACHA20-POLY1305
* ALPN, server accepted to use h2
* Server certificate:
*  subject: O=example; CN=foo.example.com
*  start date: Sep  1 10:32:03 2021 GMT
*  expire date: Aug 27 10:32:03 2022 GMT
*  common name: foo.example.com (matched)
*  issuer: O=example; CN=foo.example.com
*  SSL certificate verify ok.
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
* Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
* Using Stream ID: 1 (easy handle 0x7fa10f00e400)
> GET / HTTP/2
> Host: foo.example.com
> User-Agent: curl/7.64.1
> Accept: */*
>
* Connection state changed (MAX_CONCURRENT_STREAMS == 100)!
< HTTP/2 200
< content-type: application/json
< content-length: 308
< access-control-allow-origin: *
< server: Werkzeug/1.0.1 Python/3.8.6
< date: Wed, 01 Sep 2021 11:39:06 GMT
< via: 1.1 google
< alt-svc: clear
<
{"cluster_name":"gke-us","host_header":"foo.example.com","metadata":"foo","node_name":"gke-gke-us-default-pool-22cb07b1-r5r0.c.mark-church-project.internal","pod_name":"foo-75ccd9c96d-dkg8t","pod_name_emoji":"👞","project_id":"mark-church-project","timestamp":"2021-09-01T11:39:06","zone":"us-central1-b"}
* Connection #0 to host foo.example.com left intact
* Closing connection 0

    Kode responsnya adalah 200 dan TLSv1.2 digunakan, yang menunjukkan bahwa semuanya berfungsi dengan benar.

    Selanjutnya, Anda dapat memverifikasi bahwa kebijakan SSL memberlakukan versi TLS yang benar dengan mencoba terhubung ke TLS 1.1. Kebijakan SSL Anda harus dikonfigurasi untuk minimal versi 1.2 agar langkah ini berhasil.

  11. Kirim permintaan yang sama dengan langkah sebelumnya, tetapi terapkan TLS versi 1.1.

    curl https://foo.example.com --resolve foo.example.com:443:VIP -v \
  --cacert CERT_FILE \
  --tls-max 1.1

    Output yang berhasil akan terlihat seperti berikut:

    * Added foo.example.com:443:34.149.29.76 to DNS cache
* Hostname foo.example.com was found in DNS cache
*   Trying 34.149.29.76...
* TCP_NODELAY set
* Connected to foo.example.com (34.149.29.76) port 443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
*   CAfile: cert.pem
  CApath: none
* TLSv1.1 (OUT), TLS handshake, Client hello (1):
* TLSv1.1 (IN), TLS alert, protocol version (582):
* error:1400442E:SSL routines:CONNECT_CR_SRVR_HELLO:tlsv1 alert protocol version
* Closing connection 0
curl: (35) error:1400442E:SSL routines:CONNECT_CR_SRVR_HELLO:tlsv1 alert protocol version

    Kegagalan untuk menyelesaikan handshake TLS menunjukkan bahwa kebijakan SSL telah berhasil memblokir TLS 1.1.

Membuat IP statis

  1. Alokasikan IP statis:

    gcloud compute addresses create ADDRESS_NAME --global

    Ganti ADDRESS_NAME dengan nama IP statis yang akan dialokasikan.

    Output-nya berisi URL lengkap dari alamat yang Anda buat, yang mirip dengan berikut ini:

    Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME].

  2. Lihat alamat IP yang baru saja Anda buat:

    gcloud compute addresses list

    Outputnya mirip dengan hal berikut ini:

    NAME          ADDRESS/RANGE  TYPE      STATUS
ADDRESS_NAME  STATIC_IP_ADDRESS  EXTERNAL  RESERVED

    Output ini mencakup:

    • ADDRESS_NAME yang Anda tentukan.
    • STATIC_IP_ADDRESS yang dialokasikan.

  3. Perbarui file mci.yaml dengan IP statis:

    apiVersion: networking.gke.io/v1
kind: MultiClusterIngress
metadata:
  name: whereami-ingress
  namespace: whereami
  annotations:
    networking.gke.io/static-ip: STATIC_IP_ADDRESS
spec:
  template:
    spec:
      backend:
        serviceName: whereami-mcs
        servicePort: 8080

    Ganti STATIC_IP_ADDRESS dengan salah satu dari:

    • Alamat IP yang dialokasikan, yang mirip dengan: 34.102.201.47
    • URL lengkap dari alamat yang Anda buat, yang mirip dengan: "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME"

    STATIC_IP_ADDRESS bukan nama resource (ADDRESS_NAME).

  4. Deploy ulang resource MultiClusterIngress:

    kubectl apply -f mci.yaml

    Outputnya mirip dengan hal berikut ini:

    multiclusteringress.networking.gke.io/whereami-ingress configured

  5. Ikuti langkah-langkah di bagian Memvalidasi status deployment yang berhasil untuk memverifikasi bahwa deployment berfungsi di STATIC_IP_ADDRESS.

Sertifikat yang dibagikan sebelumnya

Sertifikat yang dibagikan sebelumnya adalah sertifikat yang diupload ke Google Cloud yang dapat digunakan load balancer untuk TLS termination, bukan sertifikat yang disimpan di Secret Kubernetes. Sertifikat ini diupload secara eksternal dari GKE ke Google Cloud dan direferensikan oleh resource MultiClusterIngress. Penggunaan beberapa sertifikat, baik yang dibagikan sebelumnya atau Secret Kubernetes, juga didukung.

Penggunaan sertifikat di Multi Cluster Ingress memerlukan anotasi networking.gke.io/pre-shared-certs dan nama sertifikat. Jika beberapa sertifikat ditentukan untuk sebuah MultiClusterIngress tertentu, urutan yang ditentukan sebelumnya akan mengatur sertifikat mana yang diberikan kepada klien.

Anda dapat menampilkan daftar sertifikat SSL yang tersedia dengan menjalankan:

gcloud compute ssl-certificates list

Contoh berikut menjelaskan traffic klien ke salah satu host yang ditentukan dan cocok dengan Nama Umum dari sertifikat yang dibagikan sebelumnya, sehingga masing-masing sertifikat yang cocok dengan nama domain akan ditampilkan.

kind: MultiClusterIngress
metadata:
  name: shopping-service
  namespace: whereami
  annotations:
    networking.gke.io/pre-shared-certs: "domain1-cert, domain2-cert"
spec:
  template:
    spec:
      rules:
      - host: my-domain1.gcp.com
        http:
          paths:
          - backend:
              serviceName: domain1-svc
              servicePort: 443
      - host: my-domain2.gcp.com
        http:
          paths:
          - backend:
              serviceName: domain2-svc
              servicePort: 443

Sertifikat yang dikelola Google

Sertifikat yang dikelola Google didukung di resource MultiClusterIngress melalui anotasi networking.gke.io/pre-shared-certs. Multi Cluster Ingress mendukung penambahan sertifikat yang dikelola Google ke resource MultiClusterIngress, tetapi tidak seperti Single Cluster Ingress, pembuatan resource ManagedCertificate Kubernetes secara deklaratif tidak didukung di resource MultiClusterIngress. Pembuatan asli sertifikat yang dikelola Google harus dilakukan langsung melalui compute ssl-certificates create API sebelum Anda dapat menambahkannya ke MultiClusterIngress. Hal tersebut dapat dilakukan dengan mengikuti langkah-langkah berikut:

  1. Buat Sertifikat yang dikelola Google seperti pada langkah 1 di sini. Jangan melanjutkan ke langkah 2 karena Multi Cluster Ingress akan melampirkan sertifikat ini untuk Anda.

    gcloud compute ssl-certificates create my-google-managed-cert \
    --domains=my-domain.gcp.com \
    --global

  2. Referensikan nama sertifikat di MultiClusterIngress menggunakan anotasi networking.gke.io/pre-shared-certs.

    kind: MultiClusterIngress
metadata:
name: shopping-service
namespace: whereami
annotations:
  networking.gke.io/pre-shared-certs: "my-google-managed-cert"
spec:
template:
  spec:
    rules:
    - host: my-domain.gcp.com
      http:
        paths:
        - backend:
            serviceName: my-domain-svc
            servicePort: 8080

Manifes sebelumnya menambahkan sertifikat ke MultiClusterIngress sehingga dapat menghentikan traffic untuk cluster GKE backend. Google Cloud akan memperpanjang sertifikat secara otomatis sebelum habis masa berlakunya. Perpanjangan terjadi secara transparan dan tidak memerlukan perubahan apa pun pada Multi Cluster Ingress.

Protokol aplikasi

Secara default, koneksi dari proxy load balancer ke aplikasi Anda menggunakan HTTP. Dengan anotasi networking.gke.io/app-protocols, Anda dapat mengonfigurasi load balancer agar menggunakan HTTPS atau HTTP/2 saat meneruskan permintaan ke aplikasi Anda. Di kolom annotation pada contoh berikut, http2 merujuk ke nama port MultiClusterService sedangkan HTTP2 merujuk ke protokol yang digunakan load balancer.

kind: MultiClusterService
metadata:
  name: shopping-service
  namespace: whereami
  annotations:
    networking.gke.io/app-protocols: '{"http2":"HTTP2"}'
spec:
  template:
    spec:
      ports:
      - port: 443
        name: http2

BackendConfig

Lihat bagian di atas tentang cara mengonfigurasi anotasi.

Langkah selanjutnya