Membuat pengontrol ingress yang tidak dikelola

  • Artikel

Pengontrol ingress adalah bagian dari perangkat lunak yang menyediakan proksi terbalik, perutean lalu lintas yang dapat dikonfigurasi, dan penghentian TLS untuk layanan Kube. Sumber daya ingress Kubernetes digunakan untuk mengonfigurasi aturan dan rute ingress untuk masing-masing layanan Kubernetes. Saat Anda menggunakan pengontrol ingress dan aturan ingress, satu alamat IP dapat digunakan untuk merutekan lalu lintas ke beberapa layanan di kluster Kubernetes.

Artikel ini menunjukkan cara menyebarkan pengontrol ingress NGINX di kluster Azure Kubernetes Service (AKS). Dua aplikasi kemudian dijalankan di kluster AKS, yang masing-masing dapat diakses melalui satu alamat IP.

Penting

Add-on perutean aplikasi direkomendasikan untuk masuk di AKS. Untuk informasi selengkapnya, lihat Ingress nginx terkelola dengan add-on perutean aplikasi.

Catatan

Terdapat dua pengontrol ingress sumber terbuka untuk Kubernetes berdasarkan Nginx: Satu dikelola oleh komunitas Kubernetes (kubernetes/ingress-nginx), dan satu lagi dikelola oleh NGINX, Inc. (nginxinc/kubernetes-ingress). Artikel ini akan menggunakan pengontrol ingress komunitas Kubernetes.

Sebelum Anda mulai

  • Artikel ini menggunakan Helm 3 untuk memasang ingress controller NGINX pada versi Kubernetes yang didukung. Pastikan Anda menggunakan rilis terbaru Helm dan memiliki akses ke repositori Helm ingress-nginx. Langkah-langkah yang diuraikan dalam artikel ini mungkin tidak kompatibel dengan versi bagan Helm sebelumnya, ingress controller NGINX, atau Kubernetes.
  • Artikel ini mengasumsikan Anda memiliki kluster AKS yang sudah ada dengan Azure Container Registry (ACR) terintegrasi. Untuk detail selengkapnya tentang membuat kluster AKS dengan ACR terintegrasi, lihat Mengautentikasi dengan Azure Container Registry dari Azure Kubernetes Service.
  • Titik akhir kesehatan API Kubernetes, healthz tidak digunakan lagi di Kubernetes v1.16. Anda dapat mengganti titik akhir ini dengan livez titik akhir dan readyz sebagai gantinya. Lihat titik akhir API Kubernetes untuk kesehatan guna menentukan titik akhir mana yang akan digunakan untuk skenario Anda.
  • Jika Anda menggunakan Azure CLI, artikel ini mengharuskan Anda menjalankan Azure CLI versi 2.0.64 atau yang lebih baru. Jalankan az --version untuk menemukan versinya. Jika Anda perlu memasang atau meningkatkan, lihat Memasang Azure CLI.
  • Jika Anda menggunakan Azure PowerShell, artikel ini mengharuskan Anda menjalankan Azure PowerShell versi 5.9.0 atau yang lebih baru. Jalankan Get-InstalledModule -Name Az untuk menemukan versinya. Jika Anda perlu menginstal atau meningkatkan, lihat Install modul Azure PowerShell.

Konfigurasi dasar

Untuk membuat pengontrol ingress NGINX dasar tanpa menyesuaikan default, Anda akan menggunakan Helm. Konfigurasi berikut menggunakan konfigurasi default untuk kesederhanaan. Anda dapat menambahkan parameter untuk menyesuaikan penyebaran, seperti --set controller.replicaCount=3.

Catatan

Jika Anda ingin mengaktifkan preservasi IP sumber klien untuk permintaan ke kontainer dalam kluster Anda, tambahkan --set controller.service.externalTrafficPolicy=Local ke perintah pemasangan Helm. IP sumber klien disimpan di header permintaan di bawah X-Forwarded-For. Saat Anda menggunakan pengontrol ingress dengan preservasi IP sumber klien yang diaktifkan, pass-through TLS tidak akan berfungsi.

NAMESPACE=ingress-basic

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install ingress-nginx ingress-nginx/ingress-nginx \
  --create-namespace \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
  --set controller.service.externalTrafficPolicy=Local

Catatan

Dalam tutorial ini, service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path sedang diatur ke /healthz. Ini berarti jika kode respons permintaan /healthz tidak 200, seluruh pengontrol ingress akan turun. Anda dapat mengubah nilai ke URI lain dalam skenario Anda sendiri. Anda tidak dapat menghapus bagian ini atau membatalkan set nilai, atau pengontrol ingress akan tetap tidak berfungsi. Paket ingress-nginx yang digunakan dalam tutorial ini, yang disediakan oleh Kubernetes resmi, akan selalu mengembalikan 200 kode respons jika meminta /healthz, karena dirancang sebagai backend default bagi pengguna untuk memulai dengan cepat, kecuali jika sedang ditimpa oleh aturan masuk.

Konfigurasi yang dikustomisasi

Sebagai alternatif dari konfigurasi dasar yang disajikan di bagian di atas, serangkaian langkah berikutnya akan menunjukkan cara menerapkan pengontrol ingress yang disesuaikan. Anda akan memiliki opsi untuk menggunakan alamat IP statis internal atau menggunakan alamat IP publik dinamis.

Mengimpor gambar yang digunakan sesuai bagan Helm ke ACR Anda

Untuk mengontrol versi gambar, Anda akan ingin mengimpornya ke Azure Container Registry Anda sendiri. Bagan Helm pengontrol masuknya NGINX bergantung pada tiga gambar kontainer. Gunakan az acr import untuk mengimpor gambar-gambar tersebut ke ACR Anda.

REGISTRY_NAME=<REGISTRY_NAME>
SOURCE_REGISTRY=registry.k8s.io
CONTROLLER_IMAGE=ingress-nginx/controller
CONTROLLER_TAG=v1.8.1
PATCH_IMAGE=ingress-nginx/kube-webhook-certgen
PATCH_TAG=v20230407
DEFAULTBACKEND_IMAGE=defaultbackend-amd64
DEFAULTBACKEND_TAG=1.5

az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$CONTROLLER_IMAGE:$CONTROLLER_TAG --image $CONTROLLER_IMAGE:$CONTROLLER_TAG
az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$PATCH_IMAGE:$PATCH_TAG --image $PATCH_IMAGE:$PATCH_TAG
az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG --image $DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG

Catatan

Selain mengimpor gambar kontainer, Anda juga dapat mengimpor bagan Helm ke ACR Anda. Untuk informasi selengkapnya, lihat Mendorong dan menarik bagan Helm ke Azure Container Registry.

Membuat pengontrol ingress

Untuk membuat pengontrol ingress, gunakan Helm untuk menginstal ingress-nginx. Pengontrol ingress perlu dijadwalkan pada node Linux. Node Server Windows seharusnya tidak menjalankan pengontrol ingress. Pemilih simpul ditentukan menggunakan parameter --set nodeSelector guna memberi tahu penjadwal Kubernetes untuk menjalankan pengontrol ingress NGINX pada simpul berbasis Linux.

Untuk redundansi tambahan, dua replika pengontrol ingress NGINX disebarkan dengan parameter --set controller.replicaCount. Untuk mendapatkan keuntungan penuh dari menjalankan replika pengontrol ingress, pastikan ada lebih dari satu simpul di kluster AKS Anda.

Contoh berikut membuat namespace layanan Kube untuk sumber daya ingress bernama ingress-basic dan dimaksudkan untuk bekerja di dalam namespace layanan tersebut. Tentukan namespace layanan untuk lingkungan Anda sendiri jika diperlukan. Jika kluster AKS anda bukan kontrol akses berbasis peran milik Kubernetes yang diaktifkan, tambahkan --set rbac.create=false ke perintah Helm.

Catatan

Jika Anda ingin mengaktifkan preservasi IP sumber klien untuk permintaan ke kontainer dalam kluster Anda, tambahkan --set controller.service.externalTrafficPolicy=Local ke perintah pemasangan Helm. IP sumber klien disimpan di header permintaan di bawah X-Forwarded-For. Saat Anda menggunakan pengontrol ingress dengan preservasi IP sumber klien yang diaktifkan, pass-through TLS tidak akan berfungsi.

# Add the ingress-nginx repository
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Set variable for ACR location to use for pulling images
ACR_LOGIN_SERVER=<REGISTRY_LOGIN_SERVER>

# Use Helm to deploy an NGINX ingress controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
    --version 4.7.1 \
    --namespace ingress-basic \
    --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_LOGIN_SERVER \
    --set controller.image.image=$CONTROLLER_IMAGE \
    --set controller.image.tag=$CONTROLLER_TAG \
    --set controller.image.digest="" \
    --set controller.admissionWebhooks.patch.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set controller.service.externalTrafficPolicy=Local \
    --set controller.admissionWebhooks.patch.image.registry=$ACR_LOGIN_SERVER \
    --set controller.admissionWebhooks.patch.image.image=$PATCH_IMAGE \
    --set controller.admissionWebhooks.patch.image.tag=$PATCH_TAG \
    --set controller.admissionWebhooks.patch.image.digest="" \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux \
    --set defaultBackend.image.registry=$ACR_LOGIN_SERVER \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Membuat pengontrol ingress menggunakan alamat IP internal

Secara default, pengontrol ingress NGINX dibuat dengan penugasan alamat IP publik dinamis. Persyaratan konfigurasi umum adalah menggunakan jaringan dan alamat IP internal privat. Pendekatan ini memungkinkan Anda membatasi akses ke layanan Anda ke pengguna internal, tanpa akses eksternal.

--set controller.service.loadBalancerIP Gunakan parameter dan --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true untuk menetapkan alamat IP internal ke pengontrol ingress Anda. Berikan alamat IP internal Anda sendiri untuk digunakan dengan pengontrol ingress. Pastikan bahwa alamat IP ini belum digunakan dalam jaringan virtual Anda. Jika Anda menggunakan jaringan virtual dan subnet yang ada, Anda harus mengonfigurasi kluster AKS dengan izin yang benar untuk mengelola jaringan virtual dan subnet. Untuk informasi selengkapnya, lihat Menggunakan jaringan kubenet dengan rentang alamat IP Anda sendiri di Azure Kubernetes Service (AKS) atau Mengonfigurasi jaringan Azure CNI di Azure Kubernetes Service (AKS).

# Add the ingress-nginx repository
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Set variable for ACR location to use for pulling images
ACR_LOGIN_SERVER=<REGISTRY_LOGIN_SERVER>

# Use Helm to deploy an NGINX ingress controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
    --version 4.7.1 \
    --namespace ingress-basic \
    --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_LOGIN_SERVER \
    --set controller.image.image=$CONTROLLER_IMAGE \
    --set controller.image.tag=$CONTROLLER_TAG \
    --set controller.image.digest="" \
    --set controller.admissionWebhooks.patch.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.service.loadBalancerIP=10.224.0.42 \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set controller.admissionWebhooks.patch.image.registry=$ACR_LOGIN_SERVER \
    --set controller.admissionWebhooks.patch.image.image=$PATCH_IMAGE \
    --set controller.admissionWebhooks.patch.image.tag=$PATCH_TAG \
    --set controller.admissionWebhooks.patch.image.digest="" \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux \
    --set defaultBackend.image.registry=$ACR_LOGIN_SERVER \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Periksa layanan penyeimbang beban

Periksa layanan penyeimbang beban dengan menggunakan kubectl get services.

kubectl get services --namespace ingress-basic -o wide -w ingress-nginx-controller

Saat layanan penyeimbang beban Kubernetes dibuat untuk pengontrol ingress NGINX, alamat IP ditetapkan di bawah EXTERNAL-IP, seperti yang ditunjukkan pada contoh output berikut:

NAME                       TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
ingress-nginx-controller   LoadBalancer   10.0.65.205   EXTERNAL-IP     80:30957/TCP,443:32414/TCP   1m   app.kubernetes.io/component=controller,app.kubernetes.io/instance=ingress-nginx,app.kubernetes.io/name=ingress-nginx

Jika Anda menelusuri ke alamat IP eksternal pada tahap ini, Anda akan melihat halaman 404 ditampilkan. Ini karena Anda masih perlu menyiapkan koneksi ke IP eksternal, yang dilakukan di bagian berikutnya.

Menjalankan aplikasi demo

Untuk melihat fungsi pengontrol ingress, jalankan dua aplikasi demo di kluster AKS Anda. Dalam contoh ini, Anda menggunakan kubectl apply untuk menyebarkan dua instans aplikasi Hello world sederhana.

  1. Buatlah file aks-helloworld-one.yaml dan salin dalam contoh YAML berikut:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld-one  
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld-one
  template:
    metadata:
      labels:
        app: aks-helloworld-one
    spec:
      containers:
      - name: aks-helloworld-one
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "Welcome to Azure Kubernetes Service (AKS)"
---
apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld-one  
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld-one

  2. Buatlah file aks-helloworld-two.yaml dan salin dalam contoh YAML berikut:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld-two  
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld-two
  template:
    metadata:
      labels:
        app: aks-helloworld-two
    spec:
      containers:
      - name: aks-helloworld-two
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "AKS Ingress Demo"
---
apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld-two  
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld-two

  3. Jalankan dua aplikasi demo menggunakan kubectl apply:

    kubectl apply -f aks-helloworld-one.yaml --namespace ingress-basic
kubectl apply -f aks-helloworld-two.yaml --namespace ingress-basic

Membuat rute ingress

Kedua aplikasi tersebut kini berjalan pada kluster Kubernetes. Untuk merutekan traffic ke setiap aplikasi, buat resource ingress Kube. Sumber daya ingress mengonfigurasi aturan yang merutekan lalu lintas ke salah satu dari dua aplikasi.

Dalam contoh berikut, lalu lintas ke EXTERNAL_IP/hello-world-one dirutekan ke layanan bernama aks-helloworld-one. Lalu lintas ke EXTERNAL_IP/hello-world-two dirutekan ke layanan aks-helloworld-two. Lalu lintas EXTERNAL_IP/static dirutekan ke layanan bernama aks-helloworld-one untuk aset statis.

  1. Buat file bernama hello-world-ingress.yaml dan salin dalam contoh YAML berikut:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/use-regex: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - path: /hello-world-one(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port:
              number: 80
      - path: /hello-world-two(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-two
            port:
              number: 80
      - path: /(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port:
              number: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress-static
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/rewrite-target: /static/$2
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - path: /static(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port: 
              number: 80

  2. Buat sumber daya ingress menggunakan perintah kubectl apply.

    kubectl apply -f hello-world-ingress.yaml --namespace ingress-basic

Menguji pengontrol ingress

Guna menguji rute untuk pengontrol ingress, lakukan penelusuran ke kedua aplikasi. Buka browser web ke alamat IP pengontrol ingress NGINX Anda, seperti EXTERNAL_IP. Aplikasi demo pertama ditampilkan di browser web, seperti yang ditunjukkan dalam contoh berikut:

First app running behind the ingress controller

Sekarang tambahkan jalur /hello-world-two ke alamat IP, seperti EXTERNAL_IP/hello-world-two. Aplikasi demo kedua dengan judul kustom ditampilkan:

Second app running behind the ingress controller

Menguji alamat IP internal

  1. Buat pod pengujian dan lampirkan sesi terminal ke dalamnya.

    kubectl run -it --rm aks-ingress-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0 --namespace ingress-basic

  2. Instal curl di pod menggunakan apt-get.

    apt-get update && apt-get install -y curl

  3. Akses alamat pengontrol ingress Kubernetes Anda menggunakan curl, seperti http://10.224.0.42. Berikan alamat IP internal Anda sendiri yang ditentukan saat Anda menyebarkan pengontrol ingress.

    curl -L http://10.224.0.42

    Tidak ada jalur yang disediakan dengan alamat, sehingga pengontrol ingress default ke rute /. Aplikasi demo dikembalikan, seperti yang ditunjukkan dalam output contoh ringkas berikut:

    <!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <link rel="stylesheet" type="text/css" href="/static/default.css">
    <title>Welcome to Azure Kubernetes Service (AKS)</title>
[...]

  4. Tambahkan jalur /hello-world-two ke alamat, seperti http://10.224.0.42/hello-world-two.

    curl -L -k http://10.224.0.42/hello-world-two

    Aplikasi demo kedua dengan judul kustom dikembalikan, seperti yang ditunjukkan dalam contoh output ringkas berikut:

    <!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <link rel="stylesheet" type="text/css" href="/static/default.css">
    <title>AKS Ingress Demo</title>
[...]

Membersihkan sumber daya

Artikel ini menggunakan Helm untuk memasang komponen ingress, sertifikat, dan aplikasi contoh. Saat Anda menyebarkan bagan Helm, sejumlah sumber daya Kubernetes dibuat. Sumber daya ini mencakup pod, penyebaran, dan layanan. Untuk membersihkan sumber daya ini, Anda dapat menghapus seluruh namespace layanan sampel, atau sumber daya individu.

Menghapus namespace layanan sampel dan semua sumber daya

Untuk menghapus seluruh namespace layanan sampel, gunakan perintah kubectl delete dan tentukan nama namespace layanan Anda. Semua sumber daya di namespace layanan dihapus.

kubectl delete namespace ingress-basic

Menghapus sumber daya satu per satu

Atau, pendekatan yang lebih terperinci adalah menghapus sumber daya yang dibuat satu per satu.

  1. Cantumkan rilis Helm dengan perintah helm list.

    helm list --namespace ingress-basic

    Cari bagan bernama ingress-nginx dan aks-helloworld, seperti yang ditunjukkan pada contoh output berikut:

    NAME                    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
ingress-nginx           ingress-basic   1               2020-01-06 19:55:46.358275 -0600 CST    deployed        nginx-ingress-1.27.1    0.26.1

  2. Copot pemasangan rilis dengan perintah helm uninstall.

    helm uninstall ingress-nginx --namespace ingress-basic

  3. Hapus dua aplikasi sampel.

    kubectl delete -f aks-helloworld-one.yaml --namespace ingress-basic
kubectl delete -f aks-helloworld-two.yaml --namespace ingress-basic

  4. Hapus rute masuk yang mengarahkan lalu lintas ke aplikasi sampel.

    kubectl delete -f hello-world-ingress.yaml

  5. Hapus namespace menggunakan kubectl delete perintah dan tentukan nama namespace Anda.

    kubectl delete namespace ingress-basic

Langkah berikutnya

Untuk mengonfigurasi TLS dengan komponen ingress Anda yang sudah ada, lihat Menggunakan TLS dengan pengontrol ingress.

Untuk mengonfigurasi kluster AKS Anda untuk menggunakan perutean aplikasi HTTP, lihat Mengaktifkan add-on perutean aplikasi HTTP.

Artikel ini menyertakan beberapa komponen eksternal ke AKS. Untuk mempelajari komponen ini lebih lanjut, lihat halaman proyek berikut: