Speciális NGINX bejövőforgalom-vezérlő és bejövő konfigurációk az alkalmazás útválasztási bővítményével

Az alkalmazás-útválasztási bővítmény két módon konfigurálja a bejövő vezérlőket és a bejövő objektumokat:

• Az NGINX bejövőforgalom-vezérlő konfigurációja, például több vezérlő létrehozása, privát terheléselosztók konfigurálása és statikus IP-címek beállítása.
• Konfiguráció bejövő erőforrásonként széljegyzeteken keresztül.

Előfeltételek

Egy AKS-fürt az alkalmazás-útválasztási bővítményrel.

Csatlakozás az AKS-fürthöz

Ha a helyi számítógépről szeretne csatlakozni a Kubernetes-fürthöz, használja kubectla Kubernetes parancssori ügyfelet. Telepítheti helyileg az az aks install-cli paranccsal. Ha az Azure Cloud Shellt használja, a kubectl már telepítve van.

Konfigurálja a kubectl-et a Kubernetes-fürthöz való csatlakozáshoz a az aks get-credentials parancs használatával.

az aks get-credentials --resource-group <ResourceGroupName> --name <ClusterName>

Az NGINX bejövőforgalom-vezérlő konfigurálása

Az alkalmazás-útválasztási bővítmény egy Kubernetes egyéni erőforrásdefiníciót (CRD)NginxIngressController használ az NGINX bejövő vezérlők konfigurálásához. Létrehozhat további bejövő vezérlőket, vagy módosíthatja a meglévő konfigurációt.

Íme egy hivatkozás a konfigurálható NginxIngressControllertulajdonságokra.

Gyakori konfigurációk

Az alapértelmezett NGINX bejövőforgalom-vezérlő konfigurációjának szabályozása (előzetes verzió)

Ha engedélyezi az alkalmazás-útválasztási bővítményt az NGINX használatával, létrehoz egy bejövő vezérlőt default , amelyet egy app-routing-namespace nyilvános azure-terheléselosztóval konfigurált. Ez a bejövőforgalom-vezérlő a bejövő osztály nevét webapprouting.kubernetes.azure.comhasználja.

Azt is szabályozhatja, hogy az alapértelmezett nyilvános vagy belső IP-címet kap-e, vagy egyáltalán létrejön-e a bővítmény engedélyezésekor.

Íme a lehetséges konfigurációs beállítások:

• None: Az alapértelmezett Nginx bejövőforgalom-vezérlő nem jön létre, és nem törlődik, ha már létezik. A felhasználóknak manuálisan kell törölnie az alapértelmezett NginxIngressController egyéni erőforrást, ha szükséges.
• Internal: Az alapértelmezett Nginx bejövőforgalom-vezérlő egy belső terheléselosztóval jön létre. Az egyéni erőforráson a külsővé alakítandó széljegyzetek felülíródnak NginxIngressController .
• External: Az alapértelmezett Nginx bejövőforgalom-vezérlő, amelyet külső terheléselosztóval hoztak létre. A rendszer felülírja az egyéni erőforráson a NginxIngressController belsővé alakítandó széljegyzeteket.
• AnnotationControlled (alapértelmezett): Az alapértelmezett Nginx bejövőforgalom-vezérlő egy külső terheléselosztóval jön létre. A felhasználók szerkeszthetik az alapértelmezett NginxIngressController egyéni erőforrást a terheléselosztó széljegyzeteinek konfigurálásához.

az aks create \
--resource-group <ResourceGroupName> \
--name <ClusterName> \
--location <Location> \
--enable-app-routing \
--app-routing-default-nginx-controller <DefaultIngressControllerType>

az aks approuting update --resource-group <ResourceGroupName> --name <ClusterName> --nginx <DefaultIngressControllerType>

"ingressProfile": {
  "webAppRouting": {
    "nginx": {
        "defaultIngressControllerType": "None|Internal|External|AnnotationControlled"
    }
}

Másik nyilvános NGINX bejövőforgalom-vezérlő létrehozása

Egy másik NGINX bejövő vezérlő létrehozása nyilvános Azure Load Balancerrel:

1. Másolja a következő YAML-jegyzékfájlt egy nginx-public-controller.yaml nevű új fájlba, és mentse a fájlt a helyi számítógépre.

   apiVersion: approuting.kubernetes.azure.com/v1alpha1
   kind: NginxIngressController
   metadata:
     name: nginx-public
   spec:
     ingressClassName: nginx-public
     controllerNamePrefix: nginx-public
   

2. Hozza létre az NGINX bejövőforgalom-vezérlő erőforrásait a kubectl apply paranccsal.

   kubectl apply -f nginx-public-controller.yaml
   

   A következő példakimenet a létrehozott erőforrást mutatja be:

   nginxingresscontroller.approuting.kubernetes.azure.com/nginx-public created
   

Belső NGINX bejövőforgalom-vezérlő létrehozása privát IP-címmel

NGINX bejövőforgalom-vezérlő létrehozása privát IP-címmel rendelkező belső Azure Load Balancerrel:

1. Másolja a következő YAML-jegyzékfájlt egy nginx-internal-controller.yaml nevű új fájlba, és mentse a fájlt a helyi számítógépre.

   apiVersion: approuting.kubernetes.azure.com/v1alpha1
   kind: NginxIngressController
   metadata:
     name: nginx-internal
   spec:
     ingressClassName: nginx-internal
     controllerNamePrefix: nginx-internal
     loadBalancerAnnotations: 
       service.beta.kubernetes.io/azure-load-balancer-internal: "true"
   

2. Hozza létre az NGINX bejövőforgalom-vezérlő erőforrásait a kubectl apply paranccsal.

   kubectl apply -f nginx-internal-controller.yaml
   

   A következő példakimenet a létrehozott erőforrást mutatja be:

   nginxingresscontroller.approuting.kubernetes.azure.com/nginx-internal created
   

NGINX bejövőforgalom-vezérlő létrehozása statikus IP-címmel

NGINX bejövőforgalom-vezérlő létrehozása statikus IP-címmel az Azure Load Balancerben:

1. Hozzon létre egy Azure-erőforráscsoportot a az group create paranccsal.

   az group create --name myNetworkResourceGroup --location eastus
   

2. Hozzon létre egy statikus nyilvános IP-címet a az network public ip create paranccsal.

   az network public-ip create \
       --resource-group myNetworkResourceGroup \
       --name myIngressPublicIP \
       --sku Standard \
       --allocation-method static
   

   Feljegyzés

   Ha alapszintű termékváltozatú terheléselosztót használ az AKS-fürtben, használja az Alapszintű paramétert a --sku nyilvános IP-cím definiálásakor. Csak az alapszintű termékváltozat-ip-címek működnek az alapszintű termékváltozat terheléselosztójával, és csak a standard termékváltozatú IP-címek működnek a standard termékváltozatú terheléselosztókkal.

3. Győződjön meg arról, hogy az AKS-fürt által használt fürtidentitás delegált engedélyekkel rendelkezik a nyilvános IP-cím erőforráscsoportjára a az role assignment create parancs használatával.

   Feljegyzés

   Frissítse <ClusterName> az <ClusterResourceGroup> AKS-fürt nevét és az erőforráscsoport nevét.

   CLIENT_ID=$(az aks show --name <ClusterName> --resource-group <ClusterResourceGroup> --query identity.principalId -o tsv)
   RG_SCOPE=$(az group show --name myNetworkResourceGroup --query id -o tsv)
   az role assignment create \
       --assignee ${CLIENT_ID} \
       --role "Network Contributor" \
       --scope ${RG_SCOPE}
   

4. Másolja a következő YAML-jegyzékfájlt egy nginx-staticip-controller.yaml nevű új fájlba, és mentse a fájlt a helyi számítógépre.

   Feljegyzés

   service.beta.kubernetes.io/azure-pip-name Használhatja a nyilvános IP-címet, vagy használhatja service.beta.kubernetes.io/azure-load-balancer-ipv4 egy IPv4-címhez és service.beta.kubernetes.io/azure-load-balancer-ipv6 egy IPv6-címhez, ahogyan az a YAML-példában látható. A service.beta.kubernetes.io/azure-pip-name széljegyzet hozzáadása biztosítja a leghatékonyabb LoadBalancer-létrehozást, és erősen ajánlott a lehetséges szabályozás elkerülése érdekében.

   apiVersion: approuting.kubernetes.azure.com/v1alpha1
   kind: NginxIngressController
   metadata:
     name: nginx-static
   spec:
     ingressClassName: nginx-static
     controllerNamePrefix: nginx-static
     loadBalancerAnnotations: 
       service.beta.kubernetes.io/azure-pip-name: "myIngressPublicIP"
       service.beta.kubernetes.io/azure-load-balancer-resource-group: "myNetworkResourceGroup"
   

5. Hozza létre az NGINX bejövőforgalom-vezérlő erőforrásait a kubectl apply paranccsal.

   kubectl apply -f nginx-staticip-controller.yaml
   

   A következő példakimenet a létrehozott erőforrást mutatja be:

   nginxingresscontroller.approuting.kubernetes.azure.com/nginx-static created
   

Ellenőrizze, hogy a bejövőforgalom-vezérlő létrejött-e

A parancs használatával kubectl get nginxingresscontroller ellenőrizheti az NGINX bejövőforgalom-vezérlő állapotát.

kubectl get nginxingresscontroller -n <IngressControllerName>

Az alábbi példakimenet a létrehozott erőforrást mutatja be. Eltarthat néhány percig, amíg a vezérlő elérhetővé válik:

NAME           INGRESSCLASS   CONTROLLERNAMEPREFIX   AVAILABLE
nginx-public   nginx-public   nginx                  True

Megtekintheti a problémák elhárításának feltételeit is:

kubectl get nginxingresscontroller -n <IngressControllerName> -o jsonpath='{range .items[*].status.conditions[*]}{.lastTransitionTime}{"\t"}{.status}{"\t"}{.type}{"\t"}{.message}{"\n"}{end}'

Az alábbi példakimenet egy kifogástalan bejövőforgalom-vezérlő feltételeit mutatja be:

2023-11-29T19:59:24Z    True    IngressClassReady       Ingress Class is up-to-date
2023-11-29T19:59:50Z    True    Available               Controller Deployment has minimum availability and IngressClass is up-to-date
2023-11-29T19:59:50Z    True    ControllerAvailable     Controller Deployment is available
2023-11-29T19:59:25Z    True    Progressing             Controller Deployment has successfully progressed

Bejövő forgalom vezérlőjének használata

1. Másolja a következő YAML-jegyzékfájlt egy ingress.yaml nevű új fájlba, és mentse a fájlt a helyi számítógépre.

   Feljegyzés

   Frissítsen <Hostname> a DNS-gazdagép nevével. Ez <IngressClassName> az, amelyet a rendszer létrehozásakor NginxIngressControllerdefiniált.

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: aks-helloworld
     namespace: hello-web-app-routing
   spec:
     ingressClassName: <IngressClassName>
     rules:
     - host: <Hostname>
       http:
         paths:
         - backend:
             service:
               name: aks-helloworld
               port:
                 number: 80
           path: /
           pathType: Prefix
   

2. Hozza létre a fürterőforrásokat a kubectl apply paranccsal.

   kubectl apply -f ingress.yaml -n hello-web-app-routing
   

   A következő példakimenet a létrehozott erőforrást mutatja be:

   ingress.networking.k8s.io/aks-helloworld created
   

A felügyelt bejövő forgalom létrehozásának ellenőrzése

A parancs használatával ellenőrizheti, hogy a felügyelt bejövő forgalom létrejött-e kubectl get ingress .

kubectl get ingress -n hello-web-app-routing

Az alábbi példakimenet a létrehozott felügyelt bejövő forgalmat mutatja. A bejövő osztály, a gazdagép és az IP-cím eltérő lehet:

NAME             CLASS                                HOSTS               ADDRESS       PORTS     AGE
aks-helloworld   webapprouting.kubernetes.azure.com   myapp.contoso.com   20.51.92.19   80, 443   4m

Bejövőforgalom-vezérlők tisztítása

A parancs használatával eltávolíthatja az NGINX bejövőforgalom-vezérlőt kubectl delete nginxingresscontroller .

kubectl delete nginxingresscontroller -n <IngressControllerName>

Bejövő erőforrásonkénti konfiguráció széljegyzetekkel

Az NGINX bejövőforgalom-vezérlője támogatja a megjegyzéseket adott bejövő objektumokhoz a viselkedés testreszabásához.

A bemeneti objektumot a megfelelő széljegyzet hozzáadásával jegyzetelheti meg a metadata.annotations mezőben.

Íme néhány példa a gyakori konfigurációkhoz használható széljegyzetekre. Tekintse át az NGINX bejövőjegyzetek dokumentációját a teljes listához.

Egyéni maximális törzsméret

Az NGINX esetében a rendszer 413-es hibát ad vissza az ügyfélnek, ha a kérelem mérete meghaladja az ügyfélkérés törzsének megengedett maximális méretét. Az alapértelmezett érték felülbírálásához használja a megjegyzést:

nginx.ingress.kubernetes.io/proxy-body-size: 4m

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/proxy-body-size: 4m
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

Egyéni kapcsolat időtúllépése

Módosíthatja azt az időt, amikor az NGINX bejövőforgalom-vezérlője megvárja a kapcsolat bezárását a számítási feladattal. Minden időtúllépési érték egységtelen és másodpercben van megadva. Az alapértelmezett időtúllépés felülbírálásához az alábbi széljegyzettel állítson be érvényes 120 másodperces proxyolvasási időtúllépést:

nginx.ingress.kubernetes.io/proxy-read-timeout: "120"

Tekintse át az egyéni időtúllépéseket más konfigurációs beállítások esetében.

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/proxy-read-timeout: "120"
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

Háttérprotokoll

Alapértelmezés szerint az NGINX bejövőforgalom-vezérlő a szolgáltatások elérésére használja HTTP . Alternatív háttérprotokollok( például HTTPS vagy GRPC) konfigurálásához használja a megjegyzést:

nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"

vagy

nginx.ingress.kubernetes.io/backend-protocol: "GRPC"

Tekintse át az egyéb konfigurációs beállítások háttérprotokolljait .

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

Eltérő eredetű erőforrások megosztása (CORS)

Ha engedélyezni szeretné a forrásközi erőforrás-megosztást (CORS) egy bejövő szabályban, használja a megjegyzést:

nginx.ingress.kubernetes.io/enable-cors: "true"

Tekintse át a CORS engedélyezését más konfigurációs beállításokhoz.

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/enable-cors: "true"
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

SSL-átirányítás letiltása

Alapértelmezés szerint a vezérlő (308) HTTPS-re irányítja át, ha a TLS engedélyezve van a bejövő forgalomhoz. Ha le szeretné tiltani ezt a funkciót adott bejövő erőforrások esetében, használja a megjegyzést:

nginx.ingress.kubernetes.io/ssl-redirect: "false"

Tekintse át a kiszolgálóoldali HTTPS-kényszerítéseket átirányítással más konfigurációs beállítások esetében.

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

URL-újraírás

Bizonyos esetekben a háttérszolgáltatás közzétett URL-címe eltér a bejövőforgalom-szabályban megadott elérési úttól. Átírás nélkül minden kérés a 404-et adja vissza. Ez a konfiguráció az útvonalalapú útválasztással hasznos, ahol két különböző webalkalmazást is kiszolgálhat ugyanazon a tartományon belül. A szolgáltatás által várt elérési utat a széljegyzet használatával állíthatja be:

nginx.ingress.kubernetes.io/rewrite-target": /$2

Íme egy példa a bejövő forgalom konfigurálásához ezzel a megjegyzéssel:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
    nginx.ingress.kubernetes.io/use-regex: "true"
spec:
  ingressClassName: <IngressClassName>
  rules:
  - host: <Hostname>
    http:
      paths:
      - path: /app-one(/|$)(.*)
        pathType: Prefix 
        backend:
          service:
            name: app-one
            port:
              number: 80
      - path: /app-two(/|$)(.*)
        pathType: Prefix 
        backend:
          service:
            name: app-two
            port:
              number: 80

Következő lépések

Az alkalmazás teljesítményének és használatának elemzése során megismerheti az alkalmazás-útválasztási bővítmény bejövő nginx vezérlőmetrikáinak monitorozását a Grafana Prometheus használatával.