Membuat Layanan dan Ingress

Dokumen ini menunjukkan cara membuat objek Ingress Kubernetes di cluster pengguna, hybrid, atau mandiri untuk Google Distributed Cloud. Ingress dikaitkan dengan satu atau beberapa Layanan, yang masing-masing dikaitkan dengan sekumpulan Pod.

Membuat Deployment

Gunakan langkah-langkah berikut untuk membuat Deployment:

1. Buat manifes Deployment:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-deployment
   spec:
     selector:
       matchLabels:
         greeting: hello
     replicas: 3
     template:
       metadata:
         labels:
           greeting: hello
       spec:
         containers:
         - name: hello-world
           image: "gcr.io/google-samples/hello-app:2.0"
           env:
           - name: "PORT"
             value: "50000"
         - name: hello-kubernetes
           image: "gcr.io/google-samples/node-hello:1.0"
           env:
           - name: "PORT"
             value: "8080"
   

   Untuk tujuan latihan ini, berikut adalah poin-poin penting yang perlu dipahami tentang manifes Deployment:

   • Setiap Pod yang termasuk dalam Deployment memiliki label greeting: hello.

   • Setiap Pod memiliki dua container.

   • Kolom env menentukan bahwa container hello-app memproses port TCP 50000, dan container node-hello memproses port TCP 8080. Untuk hello-app, Anda dapat melihat efek variabel lingkungan PORT dengan melihat kode sumber.

2. Salin manifes ke file bernama hello-deployment.yaml.

3. Membuat Deployment:

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-deployment.yaml
   

   Ganti CLUSTER_KUBECONFIG dengan nama file kubeconfig untuk cluster Anda.

Mengekspos Deployment Anda dengan Service

Untuk menyediakan cara yang stabil bagi klien untuk mengirim permintaan ke Pod Deployment Anda, buat Service:

1. Buat manifes Layanan yang mengekspos Deployment Anda ke klien di dalam cluster Anda:

   apiVersion: v1
   kind: Service
   metadata:
     name: hello-service
   spec:
     type: ClusterIP
     selector:
       greeting: hello
     ports:
     - name: world-port
       protocol: TCP
       port: 60000
       targetPort: 50000
     - name: kubernetes-port
       protocol: TCP
       port: 60001
       targetPort: 8080
   

2. Salin manifes ke file bernama hello-service.yaml.

3. Buat Layanan:

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-service.yaml
   

   Ganti CLUSTER_KUBECONFIG dengan nama file kubeconfig untuk cluster Anda.

4. Lihat Service:

   kubectl --kubeconfig CLUSTER_KUBECONFIG get service hello-service --output yaml
   

   Output menampilkan nilai clusterIP yang telah diberikan ke Layanan. Contoh:

   apiVersion: v1
   kind: Service
   metadata:
     annotations:
       ...
   spec:
     clusterIP: 10.96.14.249
     clusterIPs:
     - 10.96.14.249
     ipFamilies:
     - IPv4
     ipFamilyPolicy: SingleStack
     ports:
     - name: world-port
       port: 60000
       protocol: TCP
       targetPort: 50000
     - name: kubernetes-port
       port: 60001
       protocol: TCP
       targetPort: 8080
     selector:
       greeting: hello
     sessionAffinity: None
     type: ClusterIP
   status:
     loadBalancer: {}
   

   Dalam output sebelumnya, kolom ports adalah array objek ServicePort: satu bernama world-port dan satu bernama kubernetes-port. Untuk mengetahui informasi selengkapnya tentang kolom Layanan, lihat ServiceSpec dalam dokumentasi Kubernetes.

   Berikut cara klien dapat memanggil Layanan:

   • Menggunakan world-port: Klien yang berjalan di salah satu node cluster mengirim permintaan ke clusterIP di port (seperti 10.96.14.249:60000). Pengontrol ingress meneruskan permintaan ke Pod anggota di targetPort (seperti POD_IP_ADDRESS:50000, dengan POD_IP_ADDRESS adalah alamat IP Pod anggota).

   • Menggunakan kubernetes-port: Klien yang berjalan di salah satu node cluster mengirim permintaan ke clusterIP di port (10.96.14.249:60001). Pengontrol ingress meneruskan permintaan ke Pod anggota di targetPort (POD_IP_ADDRESS:8080).

Komponen ingress

Berikut adalah beberapa komponen cluster yang terkait dengan ingress:

Catatan: Komponen Istio yang telah diinstal sebelumnya di Google Distributed Cloud hanya mendukung ingress. Komponen ini tidak dimaksudkan untuk menyediakan kemampuan mesh layanan umum. Untuk mengetahui informasi tentang cara menyiapkan mesh layanan yang berfungsi penuh, lihat Penyiapan dalam dokumentasi Istio atau Menyiapkan mesh multi-cluster di luarGoogle Cloud dalam dokumentasi Cloud Service Mesh.

• Deployment istio-ingress. Ini adalah proxy ingress. Proxy ingress meneruskan traffic ke Layanan internal sesuai dengan aturan yang ditentukan dalam objek Ingress.

• Layanan istio-ingress. Layanan ini mengekspos istio-ingress Deployment.

• Deployment istiod. Ini adalah pengontrol ingress. Pengontrol ingress memantau pembuatan objek Ingress dan mengonfigurasi proxy ingress yang sesuai.

Semua komponen dalam cluster Istio ini diinstal di namespace gke-system. Namespace ini tidak berkonflik dengan penginstalan Istio/Cloud Service Mesh lengkap.

Membuat Ingress

Gunakan langkah-langkah berikut untuk membuat Ingress:

1. Buat manifes Ingress:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: my-ingress
   spec:
     rules:
     - http:
         paths:
         - path: /greet-the-world
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60000
         - path: /greet-kubernetes
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60001
   

2. Salin manifes ke file bernama my-ingress.yaml.

3. Buat Ingress:

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress.yaml
   

Saat membuat cluster pengguna, Anda menentukan nilai untuk loadbalancer.ingressVIP dalam file konfigurasi cluster. Alamat IP ini dikonfigurasi di load balancer cluster. Saat Anda membuat Ingress, Ingress diberi VIP yang sama ini sebagai alamat IP eksternalnya.

Saat klien mengirim permintaan ke VIP ingress cluster pengguna Anda, permintaan tersebut akan dirutekan ke load balancer Anda. Load balancer menggunakan istio-ingress Service untuk meneruskan permintaan ke proxy ingress, yang berjalan di cluster pengguna Anda. Proxy ingress meneruskan permintaan ke backend yang berbeda, bergantung pada jalur di URL permintaan.

Jalur /greet-the-world

Dalam manifes Ingress, Anda dapat melihat aturan yang menyatakan bahwa jalur /greet-the-world dikaitkan dengan serviceName: hello-service dan servicePort: 60000. Ingatlah bahwa 60000 adalah nilai port di bagian world-port pada Service hello-service Anda.

- name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000

Layanan ingress meneruskan permintaan ke clusterIP:50000. Permintaan kemudian diteruskan ke salah satu Pod anggota Service hello-service. Container, di Pod tersebut, yang memproses port 50000 akan menampilkan pesan Hello World!.

Jalur /greet-kubernetes

Dalam manifes Ingress, Anda dapat melihat aturan yang menyatakan bahwa jalur /greet-kubernetes dikaitkan dengan serviceName: hello-service dan servicePort: 60001. Ingat bahwa 60001 adalah nilai port di bagian kubernetes-port pada Service hello-service Anda.

- name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080

Layanan ingress meneruskan permintaan ke clusterIP: 8080. Permintaan kemudian diteruskan ke salah satu Pod anggota Service hello-service. Container di Pod tersebut, yang memproses port 8080, menampilkan pesan Hello Kubernetes!.

Menguji Ingress

1. Uji Ingress menggunakan jalur /greet-the-world:

   curl CLUSTER_INGRESS_VIP/greet-the-world
   

   Ganti CLUSTER_INGRESS_VIP dengan alamat IP eksternal Ingress.

   Output menampilkan pesan Hello, world!:

   Hello, world!
   Version: 2.0.0
   Hostname: ...
   

2. Uji Ingress menggunakan jalur /greet-kubernetes:

   curl CLUSTER_INGRESS_VIP/greet-kubernetes
   

   Output menampilkan pesan Hello, Kubernetes!:

   Hello Kubernetes!
   

Menonaktifkan Ingress yang dibundel

Kemampuan Ingress yang disertakan dengan Google Distributed Cloud hanya mendukung kemampuan ingress. Anda dapat memilih untuk melakukan integrasi dengan Istio atau Cloud Service Mesh. Produk ini menawarkan manfaat tambahan dari mesh layanan yang berfungsi penuh, seperti Mutual Transport Layer Security (mTLS), kemampuan untuk mengelola autentikasi antar-layanan, dan kemampuan observasi workload. Jika Anda berintegrasi dengan Istio atau Cloud Service Mesh, sebaiknya nonaktifkan kemampuan Ingress yang disertakan.

Anda dapat mengaktifkan atau menonaktifkan Ingress bawaan dengan kolom spec.clusterNetwork.bundledIngress di file konfigurasi cluster. Kolom ini hanya tersedia untuk cluster versi 1.13.0 dan yang lebih tinggi. Kolom bundledIngress secara default adalah true dan tidak ada dalam file konfigurasi cluster yang dihasilkan. Kolom ini dapat diubah dan dapat diubah saat Anda membuat atau mengupdate cluster versi 1.13.0 atau yang lebih tinggi.

• Untuk menonaktifkan kemampuan Ingress paket, tambahkan kolom bundledIngress ke bagian clusterNetwork dari file konfigurasi cluster Anda dan tetapkan nilainya ke false, seperti yang ditunjukkan dalam contoh berikut:

  apiVersion: v1
  kind: Namespace
  metadata:
    name: cluster-hybrid-basic
  ---
  apiVersion: baremetal.cluster.gke.io/v1
  kind: Cluster
  metadata:
    name: hybrid-basic
    namespace: cluster-hybrid-basic
  spec:
    type: hybrid
    profile: default
    anthosBareMetalVersion: 1.13.0
    gkeConnect:
      projectID: project-fleet
    controlPlane:
      nodePoolSpec:
        nodes:
        - address: 10.200.0.2
    clusterNetwork:
      bundledIngress: false
      pods:
        cidrBlocks:
        - 192.168.0.0/16
      services:
        cidrBlocks:
        - 10.96.0.0/20
  ...
  

Menyiapkan HTTPS untuk Ingress

Jika Anda ingin menerima permintaan HTTPS dari klien, proxy ingress harus memiliki sertifikat agar dapat membuktikan identitasnya kepada klien Anda. Proxy ini juga harus memiliki kunci pribadi untuk menyelesaikan handshake HTTPS.

Contoh berikut menggunakan entitas ini:

• Proxy ingress: Berpartisipasi dalam handshake HTTPS, lalu meneruskan paket ke Pod anggota hello-service Service.

• Domain untuk Layanan hello-service: altostrat.com di Example Org

Ikuti langkah-langkah berikut:

1. Buat sertifikat root dan kunci pribadi. Contoh ini menggunakan otoritas sertifikat root root.ca.example.com di Root CA Example Org.

   openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj \
       '/O=Root CA Example Inc./CN=root.ca.example.com' -keyout root-ca.key \
       -out root-ca.crt
   

2. Buat permintaan penandatanganan sertifikat:

    openssl req -out server.csr -newkey rsa:2048 -nodes -keyout server.key -subj \
        "/CN=altostrat.com/O=Example Org"
   

3. Buat sertifikat penayangan untuk proxy ingress.

   openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 \
       -in server.csr -out server.crt
   

   Anda kini telah membuat sertifikat dan kunci berikut:

   • root-ca.crt: Sertifikat untuk CA root
   • root-ca.key: Kunci pribadi untuk CA root
   • server.crt: Menyajikan sertifikat untuk proxy ingress
   • server.key: Kunci pribadi untuk proxy ingress

4. Buat Secret Kubernetes yang menyimpan sertifikat dan kunci penayangan.

   kubectl create secret tls example-server-creds --key=server.key --cert=server.crt \
       --namespace gke-system
   

   Secret yang dihasilkan diberi nama example-server-creds.

   Catatan: Secret TLS harus ditentukan di namespace gke-system.

Membuat Deployment dan Layanan

Jika Anda membuat Deployment dan Service di bagian HTTP dalam panduan ini, biarkan keduanya tetap ada. Jika Anda belum melakukannya, buat sekarang, dengan mengikuti langkah-langkah yang dijelaskan untuk HTTP.

Membuat Ingress

Membuat Ingress untuk HTTPS mirip dengan membuat Ingress untuk HTTP, tetapi spesifikasi Ingress untuk HTTPS menyertakan bagian tls yang menentukan host dan Secret. hosts di bagian tls harus secara eksplisit cocok dengan host di bagian rules.

Peringatan: Jangan membuat beberapa Ingress untuk host yang sama. Saat menggunakan komponen ingress yang dibundel, Anda dibatasi untuk satu resource kustom Ingress untuk host tertentu.

Jika Layanan backend Anda berada di namespace terpisah, Anda perlu membuat Layanan jenis ExternalName di namespace yang sama dengan Ingress untuk merutekan traffic ke Layanan backend.

Langkah-langkah umum untuk membuat Ingress untuk HTTPS atau HTTP sama, kecuali untuk apa yang Anda konfigurasi dalam file manifes:

1. Jika sebelumnya Anda membuat Ingress di bagian HTTP dalam dokumen ini, hapus Ingress tersebut sebelum melanjutkan.

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
   

2. Untuk menangani traffic Layanan yang Anda buat sebelumnya, buat manifes Ingress baru yang memiliki bagian tls:

   Konfigurasi tls mengaktifkan HTTPS antara klien dan proxy ingress.

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: my-ingress-2
   spec:
     tls:
     - hosts:
       - altostrat.com
       secretName: example-server-creds
     rules:
     - host: altostrat.com
       http:
         paths:
         - path: /greet-the-world
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60000
         - path: /greet-kubernetes
           pathType: Exact
           backend:
             service:
               name: hello-service
               port:
                 number: 60001
   

3. Simpan manifes dalam file bernama my-ingress-2.yaml, lalu buat Ingress:

   kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress-2.yaml
   

4. Pastikan Ingress dibuat dan berfungsi dengan baik dengan menguji:

   • Uji jalur /greet-the-world:

     curl -v --resolve altostrat.com:443:CLUSTER_INGRESS_VIP \
         https://altostrat.com/greet-the-world \
         --cacert root-ca.crt
     

     Output:

     Hello, world!
     Version: 2.0.0
     Hostname: hello-deployment-5ff7f68854-wqzp7
     

   • Uji jalur /greet-kubernetes:

     curl -v --resolve altostrat.com:443:CLUSTER_INGRESS_VIP \
         https://altostrat.com/greet-kubernetes --cacert root-ca.crt
     

     Output:

     Hello Kubernetes!
     

Membuat Service LoadBalancer

Service jenis LoadBalancer adalah cara lain untuk mengekspos workload Anda di luar cluster Anda. Untuk mengetahui petunjuk dan contoh pembuatan layanan jenis LoadBalancer, lihat Membuat Layanan jenis LoadBalancer di Men-deploy aplikasi.

Pembersihan

1. Hapus Ingress Anda:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
   

   Ganti INGRESS_NAME dengan nama Ingress, seperti my-ingress atau my-ingress-2.

2. Menghapus Layanan Anda:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service
   

3. Hapus Deployment Anda:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment
   

4. Hapus Layanan LoadBalancer Anda:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service service-does-not-use-nodeports