Membuat Layanan dan Ingress

Dokumen ini menunjukkan cara membuat objek Ingress Kubernetes di cluster pengguna, campuran, atau mandiri untuk Google Distributed Cloud. Ingress dikaitkan dengan satu atau beberapa Layanan, yang masing-masing dikaitkan dengan kumpulan 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 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 penampung hello-app memproses port TCP 50000, dan penampung 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 dengan Service

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

1. Buat manifes Layanan yang mengekspos Deployment 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 menunjukkan 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 lagi bernama kubernetes-port. Untuk mengetahui informasi selengkapnya tentang kolom Layanan, lihat ServiceSpec dalam dokumentasi Kubernetes.

   Berikut adalah 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 traffic masuk 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 diprainstal di Google Distributed Cloud hanya mendukung ingress. Komponen ini tidak dimaksudkan untuk menyediakan kemampuan mesh layanan umum. Untuk informasi tentang cara menyiapkan mesh layanan yang berfungsi penuh, lihat Penyiapan dalam dokumentasi Istio atau Menyiapkan mesh multi-cluster di luar Google Cloud dalam dokumentasi Cloud Service Mesh.

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

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

• Deployment istiod. Ini adalah pengontrol ingress. Pengontrol traffic masuk memantau pembuatan objek Ingress dan mengonfigurasi proxy traffic masuk sebagaimana mestinya.

Semua komponen dalam cluster Istio ini diinstal di namespace gke-system. Namespace ini tidak bertentangan 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, VIP yang sama ini akan diberikan ke Ingress sebagai alamat IP eksternalnya.

Saat klien mengirim permintaan ke VIP ingress cluster pengguna, permintaan tersebut dirutekan ke load balancer Anda. Load balancer menggunakan Layanan istio-ingress 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. Ingat bahwa 60000 adalah nilai port di bagian world-port Service hello-service Anda.

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

Layanan ingress meneruskan permintaan ke clusterIP:50000. Permintaan tersebut kemudian akan diteruskan ke salah satu Pod anggota Layanan hello-service. Penampung, di Pod tersebut, yang memproses port 50000 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 Layanan hello-service Anda.

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

Layanan ingress meneruskan permintaan ke clusterIP: 8080. Permintaan tersebut kemudian akan diteruskan ke salah satu Pod anggota Layanan hello-service. Container dalam 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 dipaketkan

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

Anda dapat mengaktifkan atau menonaktifkan Ingress yang dipaketkan dengan kolom spec.clusterNetwork.bundledIngress dalam file konfigurasi cluster. Kolom ini hanya tersedia untuk cluster versi 1.13.0 dan yang lebih tinggi. Kolom bundledIngress ditetapkan secara default ke 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 yang dipaketkan, tambahkan kolom bundledIngress ke bagian clusterNetwork di 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. 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 Layanan hello-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 root certificate authority 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 masuk.

   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: Menayangkan sertifikat untuk proxy ingress
   • server.key: Kunci pribadi untuk proxy masuk

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 belum, 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 cocok secara eksplisit dengan host di bagian rules.

Peringatan: Jangan membuat beberapa Ingress untuk host yang sama. Saat menggunakan komponen ingress yang dipaketkan, 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 keseluruhan untuk membuat Ingress untuk HTTPS atau HTTP sama, kecuali hal yang Anda konfigurasikan 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 untuk Layanan yang Anda buat sebelumnya, buat manifes Ingress baru yang memiliki bagian tls:

   Konfigurasi tls memungkinkan HTTPS antara klien dan proxy masuk.

   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 benar 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 di luar cluster. 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 Service 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