Membuat Service dan Ingress

Dokumen ini menunjukkan cara membuat Kubernetes Traffic masuk di cluster pengguna, hybrid, atau mandiri untuk Google Distributed Cloud. Ingress dikaitkan dengan satu atau beberapa Layanan, yang masing-masing terkait dengan serangkaian 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"

Tujuan latihan ini adalah hal-hal penting yang perlu dipahami tentang manifes Deployment:

• Setiap Pod yang dimiliki Deployment memiliki label greeting: hello.

• Setiap Pod memiliki dua container.

• Kolom env menentukan bahwa container hello-app memproses TCP port 50000, dan container node-hello memantau port TCP 8080. Sebagai 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 kubeconfig untuk cluster Anda.

Mengekspos Deployment dengan Layanan

Untuk menyediakan cara yang stabil bagi klien dalam mengirim permintaan ke Pod Deployment, buat Service.

Berikut adalah manifes untuk Layanan yang mengekspos Deployment Anda kepada klien di dalamnya 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 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: {}

Pada output sebelumnya, kolom ports adalah array objek ServicePort: satu bernama world-port dan satu lagi bernama kubernetes-port. Untuk informasi selengkapnya tentang bidang Service, lihat ServiceSpec dalam dokumentasi Kubernetes.

Berikut adalah cara klien dapat memanggil Layanan:

• Menggunakan world-port: Klien yang berjalan di salah satu node cluster akan mengirim permintaan ke clusterIP pada port. Dalam contoh ini, 10.96.14.249:60000. Permintaan diteruskan ke Pod anggota pada targetPort. Dalam contoh ini, POD_IP_ADDRESS:50000.

• Menggunakan kubernetes-port: Klien yang berjalan di salah satu node cluster mengirimkan permintaan ke clusterIP pada port. Dalam contoh ini, 10.96.14.249:60001. Permintaan diteruskan ke Pod anggota pada targetPort. Dalam contoh ini, POD_IP_ADDRESS:8080.

Komponen traffic masuk

Berikut beberapa komponen cluster yang terkait dengan traffic masuk:

Catatan: Komponen Istio yang sudah terinstal di Google Distributed Cloud mendukung traffic masuk saja. Komponen ini tidak dimaksudkan untuk memberikan kemampuan mesh layanan. Untuk mengetahui informasi tentang cara menyiapkan mesh layanan, 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. Traffic masuk {i>proxy<i} meneruskan lalu lintas ke Layanan internal sesuai dengan aturan yang ditentukan dalam sebuah objek Ingress.

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

• Deployment istiod. Ini adalah pengontrol masuknya. Traffic masuk {i>controller<i} mengawasi pembuatan Traffic masuk objek dan mengonfigurasi proxy masuknya sebagaimana mestinya.

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

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, dan buat elemen Traffic masuk:

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 adalah yang telah dikonfigurasi di load balancer cluster. Saat Anda membuat Ingress, Ingress diberi VIP yang sama ini sebagai alamat IP eksternalnya.

Saat klien mengirim permintaan VIP masuk cluster pengguna Anda, permintaan tersebut yang dirutekan ke load balancer. Load balancer menggunakan Layanan istio-ingress untuk meneruskan permintaan ke proxy masuk, yang berjalan di cluster pengguna. Tujuan Proxy masuk dikonfigurasi untuk meneruskan permintaan ke backend yang berbeda tergantung di jalur dalam URL permintaan.

Jalur /greet-the-world

Dalam manifes Ingress, Anda bisa melihat aturan yang menyatakan jalur tersebut /greet-the-world dikaitkan dengan serviceName: hello-service dan servicePort: 60000. Ingat kembali bahwa 60000 adalah nilai port di world-port pada Layanan hello-service Anda.

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

Layanan masuk akan meneruskan permintaan ke clusterIP:50000. Permintaan tersebut kemudian mengarah 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 bisa melihat aturan yang menyatakan jalur tersebut /greet-kubernetes dikaitkan dengan serviceName: hello-service dan servicePort: 60001. Ingat kembali bahwa 60001 adalah nilai port di kubernetes-port dari Layanan hello-service Anda.

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

Layanan masuk akan meneruskan permintaan ke clusterIP: 8080. Permintaan tersebut kemudian mengarah ke salah satu Pod anggota Service hello-service. Container, di 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 menunjukkan pesan Hello, world!:

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

Uji Ingress menggunakan jalur /greet-kubernetes:

curl CLUSTER_INGRESS_VIP/greet-kubernetes

Output menunjukkan pesan Hello, Kubernetes!:

Hello Kubernetes!

Nonaktifkan Ingress yang dipaketkan

Kemampuan masuk yang dipaketkan dengan Google Distributed Cloud hanya mendukung fungsi masuk. Anda dapat memilih untuk berintegrasi dengan Istio atau Cloud Layanan Mesh. Produk-produk ini menawarkan manfaat tambahan dari jaring layanan yang berfungsi penuh, seperti TLS bersama (mTLS), kemampuan untuk mengelola otentikasi antarlayanan, dan kemampuan observasi workload. Jika Anda berintegrasi dengan Istio atau Cloud Service Mesh, kami sebaiknya Anda menonaktifkan paket kemampuan Ingress.

Anda dapat mengaktifkan atau menonaktifkan Ingress yang dipaketkan dengan Kolom spec.clusterNetwork.bundledIngress di file konfigurasi cluster Anda. Bidang ini hanya tersedia untuk cluster versi 1.13.0 dan yang lebih tinggi. Tujuan Secara default, kolom bundledIngress ditetapkan ke true dan tidak ada dalam kolom yang dibuat file konfigurasi cluster Anda. 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 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 masuk harus memiliki sertifikat agar dapat membuktikan identitasnya kepada klien Anda. Proxy ini juga harus memiliki kunci pribadi untuk menyelesaikan handshake HTTPS.

Contoh berikut menggunakan entity ini:

• Proxy masuk: Berpartisipasi dalam handshake HTTPS, lalu meneruskan paket untuk Pod anggota Layanan hello-service.

• Domain untuk Layanan hello-service: altostrat.com di Organisasi Contoh

Ikuti langkah-langkah berikut:

1. Buat root certificate dan kunci pribadi. Contoh ini menggunakan {i>root<i} certificate authority root.ca.example.com di Organisasi Contoh Root CA.

   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 telah membuat sertifikat dan kunci berikut:

   • root-ca.crt: Sertifikat untuk root CA
   • root-ca.key: Kunci pribadi untuk root CA
   • server.crt: Sertifikat penayangan untuk proxy masuk
   • server.key: Kunci pribadi untuk proxy masuk

4. Membuat Rahasia Kubernetes yang menyimpan sertifikat dan kunci inferensi.

   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: Rahasia TLS harus ditentukan di namespace gke-system.

Membuat Deployment dan Service

Jika Anda membuat Deployment dan Service dalam bagian HTTP pada panduan ini, meninggalkannya. Jika belum, buat sekarang, dengan mengikuti langkah-langkah yang dijelaskan untuk HTTP.

Membuat Ingress

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

Hapus Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress

Untuk menangani traffic Layanan yang Anda buat sebelumnya, buat objek baru Ingres yang memiliki bagian tls. Cara ini akan mengaktifkan HTTPS antara klien dan proxy traffic 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, dan buat Ingress:

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

Konfirmasi 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 Layanan LoadBalancer

Layanan jenis LoadBalancer adalah cara lain untuk mengekspos workload Anda ke luar dari cluster Anda. Untuk petunjuk dan contoh pembuatan jenis layanan LoadBalancer, lihat Membuat Layanan dengan jenis LoadBalancer di Deploy sebuah 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.

Hapus Layanan Anda:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Hapus Deployment:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Hapus Layanan LoadBalancer Anda:

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