Terapkan beberapa pengontrol NGINX Ingress di Alibaba Cloud ACK untuk isolasi traffic - Container Service for Kubernetes

Di kluster ACK, Anda dapat menginstal beberapa pengontrol NGINX Ingress independen menggunakan aplikasi Helm, selain pengontrol default dari Add-ons. Pendekatan ini memungkinkan Anda membuat titik masuk traffic khusus untuk layanan atau lingkungan berbeda, mengisolasi traffic dengan instance SLB terpisah yang menghadap Internet dan internal-facing, atau menyediakan konfigurasi serta versi pengontrol berbeda untuk aplikasi tertentu. Berbeda dengan menggunakan satu pengontrol untuk mengelola traffic Internet-facing dan internal-facing sekaligus, pendekatan ini memberikan isolasi kesalahan dan konfigurasi secara lengkap.

Penting

Pengontrol yang Anda instal menggunakan aplikasi Helm berbeda dari pengontrol default dari Add-ons dalam aspek-aspek berikut:

Fitur terintegrasi: Pengontrol dari Add-ons menyediakan lebih banyak fitur terintegrasi, seperti rilis canary, logging dan monitoring, serta inspeksi kluster.
Tanggung jawab: Anda bertanggung jawab mengelola siklus hidup pengontrol yang diinstal menggunakan Helm, termasuk peningkatan versi, perubahan konfigurasi, dan troubleshooting.

Working principle

Setiap pengontrol diidentifikasi oleh nama IngressClass yang unik. Saat membuat resource Ingress, Anda dapat menentukan pengontrol mana yang harus memprosesnya melalui field spec.ingressClassName. Hanya pengontrol yang sesuai dengan nama IngressClass tersebut yang akan mendengarkan dan menerapkan aturan Ingress terkait, sehingga mencapai isolasi traffic.

Gambar berikut menunjukkan contoh isolasi traffic Internet-facing dan internal-facing.

Prerequisites

Versi kluster adalah 1.22 atau lebih baru.

Versi komponen untuk kluster yang menjalankan versi 1.20 atau lebih lama tidak lagi dipelihara. Untuk informasi selengkapnya, lihat [Pengumuman Produk] Akhir Masa Pemeliharaan untuk NGINX Ingress controller v1.2 dan Versi Sebelumnya. Untuk meningkatkan kluster Anda, lihat Manually upgrade an ACK cluster.

Deploy a new Ingress controller using Helm

Pada halaman ACK Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Applications > Helm.

Klik Deploy dan ikuti petunjuk di layar untuk menginstal ack-ingress-nginx-v1.

Konfigurasikan parameter kunci berikut. Anda dapat mempertahankan nilai default untuk parameter lainnya.

Parameter	Description
Application name	Nama harus unik dalam kluster. Penting Nama ini digunakan sebagai awalan untuk menghasilkan resource Service. Nama Service memiliki format `<Application Name>-ack-ingress-nginx-v1-controller`. Untuk Service LoadBalancer internal-facing, formatnya adalah `<Application Name>-ack-ingress-nginx-v1-controller-internal`. Jika panjang total melebihi 63 karakter, pembuatan resource akan gagal.
Chart	Cari dan pilih ack-ingress-nginx-v1. Chart ack-ingress-nginx tidak lagi dipelihara.
Chart Version	Untuk kluster versi 1.24 atau lebih baru: 4.0.22 atau lebih baru. Untuk kluster versi 1.22: versi dari 4.0.16 (inklusif) hingga 4.0.22 (eksklusif).
Parameters	Secara default, pengontrol NGINX Ingress diterapkan sebagai Deployment dengan dua replika. Pengontrol ini secara otomatis membuat Service Internet-facing bertipe LoadBalancer dan mengikat instance CLB sebagai titik masuk traffic. Untuk menyesuaikan konfigurasi default, lihat ack-ingress-nginx-v1 parameters. Contoh ini menerapkan pengontrol internal-facing untuk verifikasi pada langkah-langkah berikutnya. Saat deployment, atur `controller.service.external.enabled` ke `false` dan `controller.service.internal.enabled` ke `true`. Penting Saat menerapkan beberapa pengontrol, pastikan nilai controller.ingressClassResource.name dan controller.ingressClassResource.controllerValue unik dalam kluster untuk menghindari konflik nama IngressClass.

Setelah pengontrol dibuat, lihat informasinya di halaman Helm. Di bagian Basic Information, catat Namespace-nya. Di bagian Resource, catat nama IngressClass dan nama Service-nya untuk verifikasi nanti.

Verify traffic isolation

Langkah-langkah berikut mensimulasikan skenario dengan traffic Internet-facing dan internal-facing terpisah untuk memverifikasi isolasi traffic:

Pengontrol default: Pengontrol NGINX Ingress yang diterapkan dari halaman Add-ons sudah ada di kluster. Pengontrol ini diikat ke instance SLB Internet-facing dan menyediakan titik masuk Internet-facing.

Jika belum dikonfigurasi, lihat Create and use an NGINX Ingress to expose a service.
Pengontrol baru: Pengontrol baru yang dibuat pada langkah sebelumnya diikat ke instance SLB internal-facing dan hanya menyediakan layanan dalam VPC.

Pada langkah-langkah berikut, Anda akan menerapkan aplikasi contoh dan membuat aturan Ingress yang hanya ditujukan ke pengontrol baru untuk memverifikasi bahwa isolasi berfungsi.

Step 1: Deploy a test application

Buat file nginx.yaml.

Contoh berikut menerapkan aplikasi NGINX dan Service-nya.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: nginx
  sessionAffinity: None
  type: NodePort

Terapkan aplikasi contoh.
```
kubectl apply -f nginx.yaml
```

Step 2: Create and bind an Ingress rule

Buat file ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx
spec:
  # Ubah nilai berikut menjadi nama IngressClass yang Anda konfigurasi sebelumnya (controller.ingressClassResource.name).
  ingressClassName: "<YOUR_INGRESS_CLASS>"
  rules:
  # Nama domain berikut hanya untuk tujuan pengujian. Ganti dengan nama domain aktual Anda di lingkungan produksi.
  - host: foo.bar.com
    http:
      paths:
      - path: /
        backend:
          service: 
            name: nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Buat aturan Ingress.
```
kubectl apply -f ingress.yaml
```

Step 3: Test access

Ambil alamat IP SLB masing-masing pengontrol.

Alamat IP SLB pengontrol Internet-facing default:

PUBLIC_IP=$(kubectl get svc -n kube-system nginx-ingress-lb -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "Public Ingress IP: $PUBLIC_IP"

Alamat IP SLB pengontrol internal-facing baru:

# Ganti <YourNamespace> dengan namespace pengontrol baru (misalnya, default).
# Ganti <YourChartName> dengan nama aplikasi (release name) pengontrol baru.
INTERNAL_IP=$(kubectl get svc -n <YourNamespace> <YourChartName>-ack-ingress-nginx-v1-controller-internal -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "Internal Ingress IP: $INTERNAL_IP"

Mengakses aplikasi melalui pengendali akses internal (diperkirakan berhasil).

Login ke terminal dalam VPC dan jalankan perintah berikut. Kode status 200 mengonfirmasi bahwa pengontrol internal-facing meneruskan traffic dengan benar.
```
# Ganti dengan alamat IP internal aktual.
curl -o /dev/null -s -w "%{http_code}\n" -H "Host: foo.bar.com" http://$INTERNAL_IP
```
Akses aplikasi melalui pengontrol Internet-facing (diharapkan gagal).

Jalankan perintah curl. Tanggapan 404 Not Found mengonfirmasi bahwa pengontrol Internet-facing mengabaikan aturan Ingress, artinya isolasi traffic berfungsi.
```
# Ganti dengan alamat IP Internet-facing aktual.
curl -H "Host: foo.bar.com" http://$PUBLIC_IP
```

Production deployment

Perencanaan resource: Untuk memastikan ketersediaan tinggi, pertimbangkan parameter chart berikut:
- Konfigurasikan beberapa replika: controller.replicaCount
- Tetapkan permintaan dan batas resource yang sesuai: controller.resources.requests dan controller.resources.limits
- Konfigurasikan pod anti-affinity: Tambahkan aturan podAntiAffinity di bawah field controller.affinity untuk menjadwalkan Pod pada node berbeda.
Monitoring dan alerting: Aktifkan metrik dengan mengatur controller.metrics.enabled: true dan ServiceMonitor dengan mengatur controller.metrics.serviceMonitor.enabled: true. Integrasikan dengan sistem pemantauan Prometheus. Fokus pada metrik kunci seperti latensi permintaan, laju error (HTTP 4xx/5xx), dan konfigurasikan aturan peringatan.
Optimalisasi kinerja: Untuk skenario berkinerja tinggi dan latensi rendah, kami merekomendasikan menggunakan instance NLB dalam konfigurasi Service:
- Service internal-facing: controller.service.internal.loadBalancerClass: "alibabacloud.com/nlb"
- Service Internet-facing: controller.service.loadBalancerClass: "alibabacloud.com/nlb"
Pemeliharaan versi:
- Ikuti catatan rilis komponen NGINX Ingress controller untuk menerapkan perbaikan keamanan secara tepat waktu.
- Untuk isolasi yang lebih kuat, gunakan Network Policy untuk membatasi layanan backend yang dapat diakses oleh setiap pengontrol Ingress.

Appendix: Key component parameters

Parameter	Description
`controller.image.repository`	Repository image pengontrol NGINX Ingress.
`controller.image.tag`	Versi gambar pengontrol NGINX Ingress.
`controller.ingressClassResource.name`	Nama unik untuk resource IngressClass dalam kluster. Nama ini tidak boleh `nginx`, yang merupakan pengenal untuk pengontrol default.
`controller.ingressClassResource.controllerValue`	Nilai kelas pengontrol unik untuk pengontrol Ingress ini. Nilai ini tidak boleh `k8s.io/ingress-nginx`, yang merupakan pengenal untuk pengontrol default.
`controller.replicaCount`	Jumlah replika Pod pengontrol Ingress. Kami merekomendasikan mengatur nilai ini ke 2 atau lebih untuk ketersediaan tinggi.
`controller.service.enabled`	Menentukan apakah akan membuat Service bertipe LoadBalancer (Internet-facing atau internal-facing) untuk mengekspos pengontrol.
`controller.service.external.enabled`	Jika diatur ke `true`, Service SLB Internet-facing dibuat untuk mengekspos titik masuk Internet-facing.
`controller.service.internal.enabled`	Jika diatur ke `true`, Service SLB internal-facing dibuat untuk menyediakan layanan hanya dalam VPC.
`controller.kind`	Mode penyebaran pengontrol Ingress: `Deployment` atau `DaemonSet`.
`controller.electionID`	Pengenal yang digunakan untuk pemilihan leader di antara replika pengontrol. Hanya leader yang dapat memperbarui status resource Ingress. Saat menerapkan beberapa pengontrol Ingress dalam namespace yang sama, nilai ini harus unik.
`controller.metrics.enabled`	Jika diatur ke `true`, endpoint metrik Prometheus diaktifkan untuk pengontrol Ingress.
`controller.metrics.serviceMonitor.enabled`	Jika diatur ke `true`, resource ServiceMonitor dibuat, memungkinkan Prometheus secara otomatis menemukan dan mengambil metrik. Kami merekomendasikan mengaktifkan opsi ini saat `controller.metrics.enabled` diatur ke `true`.
`controller.service.loadBalancerClass`	Jenis instance SLB yang digunakan saat membuat Service Internet-facing. `"alibabacloud.com/clb"` (Default): Gunakan instance CLB. `"alibabacloud.com/nlb"`: Gunakan instance NLB.
`controller.service.internal.loadBalancerClass`	Jenis instance SLB yang digunakan saat membuat Service internal-facing. `"alibabacloud.com/clb"` (Default): Gunakan instance CLB. `"alibabacloud.com/nlb"`: Gunakan instance NLB.