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

Berikut adalah manifes untuk 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.

Salin manifes ke file bernama hello-deployment.yaml, lalu buat 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.

Berikut adalah manifes untuk Layanan yang mengekspos Deployment Anda kepada 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

Salin manifes ke file bernama hello-service.yaml, lalu buat Service:

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

Ganti CLUSTER_KUBECONFIG dengan nama file kubeconfig untuk cluster Anda.

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 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. Dalam contoh ini, 10.96.14.249:60000. Permintaan diteruskan ke Pod anggota di targetPort. Dalam contoh ini, POD_IP_ADDRESS:50000.

• Menggunakan kubernetes-port: Klien yang berjalan di salah satu node cluster mengirim permintaan ke clusterIP di port. Dalam contoh ini, 10.96.14.249:60001. Permintaan diteruskan ke Pod anggota di targetPort. Dalam contoh ini, 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 di 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

Berikut adalah manifes untuk 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

Salin manifes ke file bernama my-ingress.yaml, lalu 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 akan dirutekan ke load balancer Anda. Load balancer menggunakan Service istio-ingress untuk meneruskan permintaan ke proxy ingress, yang berjalan di cluster pengguna Anda. Proxy ingress dikonfigurasi untuk 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 diarahkan 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 diarahkan ke salah satu Pod anggota Layanan hello-service. Container, dalam Pod tersebut, yang memproses port 8080 akan menampilkan pesan Hello Kubernetes!.

Menguji Ingress

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

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 fungsi ingress. Anda dapat memilih untuk berintegrasi dengan Istio atau Cloud Service Mesh. Produk ini menawarkan manfaat tambahan dari mesh layanan yang berfungsi penuh, seperti TLS timbal balik (mTLS), 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. Anda juga dapat menentukan kolom ini saat mengupgrade cluster ke versi 1.13.0 atau yang lebih tinggi.

Contoh file konfigurasi cluster berikut menunjukkan cara mengonfigurasi cluster untuk menonaktifkan kemampuan Ingress yang dipaketkan:

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

Jika sebelumnya Anda membuat Ingress di bagian HTTP, hapus Ingress tersebut sebelum melanjutkan.

Hapus Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress

Untuk menangani traffic untuk Layanan yang Anda buat sebelumnya, buat Ingres baru yang memiliki bagian tls. Tindakan ini akan mengaktifkan HTTPS antara klien dan proxy masuk.

Berikut adalah manifes untuk 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

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

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

Konfirmasi dengan melakukan pengujian.

• 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

Hapus Ingress Anda:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME

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

Menghapus Service Anda:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Hapus Deployment Anda:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Hapus Layanan LoadBalancer Anda:

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