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:

  • 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.

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.

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