All Products
Search

This Product

    Container Service for Kubernetes:Konfigurasikan layanan gRPC untuk Nginx Ingress

    Document Center

    Container Service for Kubernetes:Konfigurasikan layanan gRPC untuk Nginx Ingress

    Last Updated:Mar 26, 2026

    Untuk mengekspos aplikasi gRPC di kluster ACK ke klien eksternal, konfigurasikan NGINX Ingress dengan anotasi nginx.ingress.kubernetes.io/backend-protocol: "GRPC". Karena gRPC berjalan di atas HTTP/2, TLS wajib diaktifkan pada Ingress.

    Prasyarat

    Sebelum memulai, pastikan Anda telah memiliki:

    • Kluster ACK dengan NGINX Ingress Controller yang telah diinstal

    • kubectl yang telah dikonfigurasi untuk terhubung ke kluster. Lihat Hubungkan ke kluster ACK melalui kubectl

    • Nama domain untuk traffic gRPC (tutorial ini menggunakan grpc.example.com)

    • Sertifikat TLS untuk domain tersebut (dibeli dari Certificate Authority (CA) atau sertifikat tanda tangan sendiri untuk pengujian)

    Cara kerja

    Ketika klien mengirim permintaan gRPC ke titik akhir Ingress, NGINX:

    1. Mengakhiri TLS dan mendekripsi traffic.

    2. Meneruskan traffic gRPC yang telah didekripsi (melalui HTTP/2) ke Pod backend pada Port 50051.

    3. Mengembalikan respons gRPC ke klien.

    Konfigurasi utama adalah anotasi backend-protocol: "GRPC", yang memberi tahu Ingress controller untuk menggunakan gRPC alih-alih HTTP saat melakukan proxy ke backend:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: grpc-ingress
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: "GRPC"  # Proxy traffic sebagai gRPC (HTTP/2)
spec:
  tls:
  - hosts:
    - grpc.example.com          # Ganti dengan domain Anda
    secretName: nginx-ingress-tls
  rules:
  - host: grpc.example.com      # Ganti dengan domain Anda
  # ...

    Contoh aplikasi YAML

    Konsol

    1. Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Workloads > Deployments.

    2. Pada halaman Deployments, klik Create from YAML, salin konten berikut ke editor templat, lalu klik Create.

      YAML aplikasi contoh

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: grpc-service
spec:
  replicas: 1
  selector:
    matchLabels:
      run: grpc-service
  template:
    metadata:
      labels:
        run: grpc-service
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/grpc-server:latest
        imagePullPolicy: Always
        name: grpc-service
        ports:
        - containerPort: 50051
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: grpc-service
spec:
  ports:
  - port: 50051
    protocol: TCP
    targetPort: 50051
  selector:
    run: grpc-service
  sessionAffinity: None
  type: NodePort

    3. Pada jendela pop-up, temukan aplikasi tanpa status yang dituju, klik View , dan verifikasi bahwa Pod berstatus Running. 

    kubectl

    1. Buat file bernama grpc.yaml dengan konten berikut:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: grpc-service
spec:
  replicas: 1
  selector:
    matchLabels:
      run: grpc-service
  template:
    metadata:
      labels:
        run: grpc-service
    spec:
      containers:
      - image: registry.cn-hangzhou.aliyuncs.com/acs-sample/grpc-server:latest
        imagePullPolicy: Always
        name: grpc-service
        ports:
        - containerPort: 50051
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: grpc-service
spec:
  ports:
  - port: 50051
    protocol: TCP
    targetPort: 50051
  selector:
    run: grpc-service
  type: NodePort

    2. Terapkan aplikasi:

      kubectl apply -f grpc.yaml

    Aplikasi contoh ini mengimplementasikan antarmuka proto berikut. Layanan Greeter mengekspos satu metode RPC unary, yaitu SayHello:

    Definisi antarmuka aplikasi contoh gRPC

    package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

    Untuk informasi lebih lanjut, lihat contoh layanan gRPC.

    Langkah 2: Simpan sertifikat TLS sebagai Secret

    gRPC berjalan di atas HTTP/2, yang mewajibkan TLS pada Ingress. Simpan sertifikat dan kunci privat Anda dalam Secret Kubernetes agar Ingress controller dapat menggunakannya.

    1. Dapatkan sertifikat TLS untuk domain Anda:

    2. Buat Secret bernama nginx-ingress-tls untuk menyimpan sertifikat dan kunci privat.

      Konsol

      1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.

      2. Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Configurations > Secrets.

      3. Pada halaman Secrets, pilih namespace default dan klik Create di pojok kiri atas. Pada panel yang muncul, konfigurasikan Secret baru lalu klik OK.

        Namenginx-ingress-tls
        TypeTLS Certificate

        Di bawah + Add, masukkan sertifikat dan kunci privat:

        • Certificates: Konten lengkap file sertifikat (.crt atau .pem).

        • Key: Konten lengkap file kunci privat (.key).

      kubectl

      Ganti <PUBLIC_CERT> dan <PRIVATE_KEY> dengan path ke file sertifikat dan file kunci privat Anda:

      # --cert: file sertifikat (.crt atau .pem)
# --key:  file kunci privat (.key)
kubectl create secret tls nginx-ingress-tls --cert <PUBLIC_CERT> --key <PRIVATE_KEY>

    Langkah 3: Konfigurasikan Ingress untuk mengekspos layanan

    1. Masuk ke Konsol ACK dan klik nama kluster. Di panel navigasi kiri, pilih Add-ons.

    2. Cari NGINX Ingress Controller dan klik Install atau Upgrade pada kartu add-on.

    3. Konfigurasikan Ingress untuk mengarahkan traffic gRPC ke layanan backend.

      Konsol

      1. Di panel navigasi kiri, pilih Network > Ingresses. Pilih namespace default dan klik Create Ingress.

      2. Konfigurasikan Ingress dengan pengaturan berikut, lalu klik OK:

        Gateway TypeNginx Ingress
        Namegrpc-ingress
        Domain Namegrpc.example.com

        Di bawah Mappings, atur:

        Mappings/
        Match RulePrefix (Prefix-based match)
        Servicegrpc-service
        Port50051

        Di bawah TLS settings, aktifkan opsi tersebut dan atur:

        Domain Namegrpc.example.com
        Secretsnginx-ingress-tls

        Di bawah Annotations, tambahkan:

        nginx.ingress.kubernetes.io/backend-protocolGRPC

      3. Pada halaman Ingresses, temukan Ingress baru dan catat Endpoint-nya.

        Dibutuhkan sekitar 10 detik agar NGINX Ingress berlaku. Jika endpoint belum muncul, tunggu dan klik refresh. Jika masih belum muncul, klik nama Ingress dan periksa tab Events untuk memecahkan masalah.

      kubectl

      1. Buat file bernama grpc-ingress.yaml:

        apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: grpc-ingress
  annotations:
    # Proxy traffic sebagai gRPC (HTTP/2) ke backend
    nginx.ingress.kubernetes.io/backend-protocol: "GRPC"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - grpc.example.com             # Ganti dengan domain Anda
    secretName: nginx-ingress-tls  # Secret yang dibuat pada langkah sebelumnya
  rules:
  - host: grpc.example.com         # Ganti dengan domain Anda
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: grpc-service
            port:
              number: 50051

      2. Terapkan Ingress:

        kubectl apply -f grpc-ingress.yaml

      3. Dapatkan alamat Endpoint. Jika tidak ada alamat yang dikembalikan, tunggu 10 detik lalu coba lagi:

        ADDRESS=$(kubectl get ingress grpc-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo $ADDRESS

    Langkah 4: Verifikasi pengaturan

    1. Tambahkan entri ke file hosts lokal Anda untuk mengarahkan domain contoh ke alamat IP Ingress: Tambahkan baris berikut, ganti <ADDRESS> dengan IP aktual:

      • macOS/Linux: Edit /etc/hosts dengan sudo vi /etc/hosts

      • Windows: Buka C:\Windows\System32\drivers\etc\hosts di Notepad (jalankan sebagai administrator)

      <ADDRESS> grpc.example.com

    2. Instal grpcurl, lalu panggil metode SayHello:

      grpcurl -d '{"name": "gRPC"}' grpc.example.com:443 helloworld.Greeter/SayHello

      Tanggapan yang diharapkan:

      {
  "message": "Hello gRPC"
}

    Batasan

    Routing berbasis bobot tidak didukung untuk gRPC. Karena koneksi gRPC bersifat long-lived, NGINX Ingress tidak mendukung routing berbasis bobot layanan (service-weight) untuk backend gRPC.

    FAQ

    Bagaimana cara membuat sertifikat tanda tangan sendiri untuk pengujian?

    Gunakan openssl untuk membuat sertifikat tanda tangan sendiri dan kunci privat yang berlaku selama 365 hari:

    openssl req -x509 -newkey rsa:2048 -keyout grpc.key -out grpc.crt -days 365 -nodes \
  -subj "/CN=grpc.example.com" \
  -addext "subjectAltName=DNS:grpc.example.com"
    Penting

    Sertifikat tanda tangan sendiri tidak dipercaya secara default oleh browser atau klien gRPC. Jangan gunakan sertifikat tanda tangan sendiri di lingkungan produksi.

    Apa perbedaan antara SSL dan TLS?

    Transport Layer Security (TLS) adalah pengganti modern dari protokol Secure Sockets Layer (SSL) yang lebih lama dan sudah tidak digunakan lagi. Dalam praktiknya, istilah "sertifikat SSL" sering digunakan secara umum untuk merujuk pada sertifikat TLS.

    Langkah selanjutnya