Halaman ini diterjemahkan oleh Cloud Translation API.

Menggunakan HTTP/2 untuk load balancing dengan Ingress

Autopilot Standard

Halaman ini menunjukkan cara menggunakan objek Ingress dan Service Kubernetes untuk mengonfigurasi Load Balancer Aplikasi eksternal agar menggunakan HTTP/2 untuk berkomunikasi dengan layanan backend.

Ringkasan

Load Balancer Aplikasi bertindak sebagai proxy antara klien dan aplikasi Anda. Klien dapat menggunakan HTTP/1.1 atau HTTP/2 untuk berkomunikasi dengan proxy load balancer. Namun, koneksi dari proxy load balancer ke aplikasi Anda menggunakan HTTP/1.1 secara default. Jika aplikasi Anda, yang berjalan di Pod Google Kubernetes Engine (GKE), dapat menerima permintaan HTTP/2, Anda dapat mengonfigurasi load balancer eksternal untuk menggunakan HTTP/2 saat meneruskan permintaan ke aplikasi Anda.

Dalam latihan ini, Anda akan membuat Deployment, Service, dan Ingress. Anda perlu menempatkan anotasi cloud.google.com/app-protocols dalam manifes Service untuk menentukan bahwa load balancer harus menggunakan HTTP/2 untuk berkomunikasi dengan aplikasi Anda. Kemudian, Anda memanggil layanan dan memverifikasi bahwa aplikasi Anda menerima permintaan HTTP/2.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region dan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location.

Baca referensi resource Ingress dan Service Kubernetes.
Baca Batasan HTTP/2 untuk Load Balancer Aplikasi eksternal.

Membuat Deployment

Salin manifes berikut ke file bernama my-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: echoheaders
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echoheaders
  template:
    metadata:
      labels:
        app: echoheaders
    spec:
      containers:
      - name: echoheaders
        image: registry.k8s.io/echoserver:1.10
        ports:
        - containerPort: 8443

Manifes ini menjelaskan Deployment dengan dua replika aplikasi web echoheaders.

Terapkan manifes ke cluster Anda:
```
kubectl apply -f my-deployment.yaml
```

Membuat Layanan

Salin manifes berikut ke file bernama my-service.yaml:
```
apiVersion: v1
kind: Service
metadata:
  annotations:
    cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
  name: echoheaders
  labels:
    app: echoheaders
spec:
  type: NodePort
  ports:
  - port: 443
    targetPort: 8443
    protocol: TCP
    name: my-port
  selector:
    app: echoheaders
```
Manifes ini menjelaskan Layanan dengan properti berikut:
- type: NodePort: Menentukan bahwa ini adalah Layanan jenis NodePort.
- app: echoheaders: Menentukan bahwa setiap Pod yang memiliki label ini adalah anggota Layanan.
- cloud.google.com/app-protocols: Menentukan bahwa my-port harus menggunakan protokol HTTP/2.
- port: 443, protocol: TCP, dan targetPort: 8433: Tentukan bahwa traffic yang diarahkan ke Layanan di port TCP 443 harus dirutekan ke port TCP 8422 di salah satu Pod anggota.
Terapkan manifes ke cluster Anda:
```
kubectl apply -f my-service.yaml
```

Lihat Service:

kubectl get service echoheaders --output yaml

Outputnya mirip dengan hal berikut ini:

apiVersion: v1
kind: Service
metadata:
  annotations:
    cloud.google.com/app-protocols: '{"my-port":"HTTP2"}'
    ...
  labels:
    app: echoheaders
  name: echoheaders
  ...
spec:
  clusterIP: 10.39.251.148
  ...
  ports:
  - name: my-port
    nodePort: 30647
    port: 443
    protocol: TCP
    targetPort: 8443
  selector:
    app: echoheaders
  ...
  type: NodePort
...

Membuat Ingress

Salin manifes berikut ke file bernama my-ingress.yaml:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: echomap
spec:
  defaultBackend:
    service:
      name: echoheaders
      port:
        number: 443
```
Manifes ini menjelaskan Ingress yang menentukan bahwa permintaan masuk dikirim ke Pod yang merupakan anggota Layanan echoheaders. Permintaan dirutekan ke Pod di targetPort yang ditentukan dalam manifes Layanan echoheaders. Dalam latihan ini, Pod targetPort adalah 8443.
Terapkan manifes ke cluster Anda:
```
kubectl apply -f my-ingress.yaml
```
Pemrosesan perintah ini dapat memerlukan waktu beberapa menit saat pengontrol Ingress Kubernetes mengonfigurasi Load Balancer Aplikasi.

Lihat Ingress:

kubectl get ingress echomap --output yaml

Outputnya mirip dengan hal berikut ini:

kind: Ingress
metadata:
  ...
  name: echomap
  ...
spec:
  backend:
    serviceName: echoheaders
    servicePort: 443
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.2

Dalam output ini, alamat IP Ingress adalah 203.0.113.2.

Menguji load balancer

gcloud

Cantumkan layanan backend Anda:
```
gcloud compute backend-services list
```

Jelaskan layanan backend Anda:

gcloud beta compute backend-services describe BACKEND_SERVICE_NAME --global

Ganti BACKEND_SERVICE_NAME dengan nama layanan backend Anda.

Output menentukan protocol adalah HTTP2:

backends:
...
description: '{...,"kubernetes.io/service-port":"443","x-features":["HTTP2"]}'
...
kind: compute#backendService
loadBalancingScheme: EXTERNAL
protocol: HTTP2
...

Konsol

Buka halaman Load balancing di Konsol Google Cloud.

Buka Load balancing
Pada bagian Nama, cari load balancer Anda.
Klik nama load balancer untuk melihat layanan backend Anda.
Pastikan Protokol endpoint untuk layanan backend Anda adalah HTTP/2.

Memanggil Service

Tunggu beberapa menit hingga GKE mengonfigurasi load balancer dan layanan backend, lalu masukkan alamat IP eksternal load balancer di kolom URL browser Anda.

Outputnya mirip dengan hal berikut ini:

Hostname: echoheaders-7886d5bc68-xnrwj
...
Request Information:
  ...
  method=GET
  real path=/
  query=
  request_version=2
  request_scheme=https
  ...

Request Headers:
  ...
  x-forwarded-for=[YOUR_IP_ADDRESS], 203.0.113.2
  x-forwarded-proto=http
...

Output ini menampilkan informasi tentang permintaan dari load balancer ke Pod:

request_version=2: Menunjukkan bahwa permintaan antara load balancer dan Pod menggunakan HTTP/2.
x-forwarded-proto=http: Menunjukkan bahwa permintaan antara browser dan load balancer menggunakan HTTP 1.1, bukan HTTP/2.

Langkah selanjutnya

Siapkan Load Balancer Aplikasi eksternal dengan Ingress.
Konfigurasikan alamat IP statis dan nama domain untuk aplikasi Anda menggunakan Ingress.
Konfigurasikan sertifikat SSL untuk load balancer Ingress.