Avancerade NGINX-ingresskontrollanter och ingresskonfigurationer med tillägget för programroutning för Azure Kubernetes Service (AKS)

Konfigurationsegenskaper för NGINX-ingresskontrollanter

Tillägget för programroutning använder en anpassad Kubernetes-resursdefinition (CRD) som kallas för att konfigurera NGINX-ingresskontrollanter. Du kan skapa fler ingresskontrollanter eller ändra befintliga konfigurationer.

I följande tabell visas egenskaper som du kan ange för att konfigurera en NginxIngressController:

Kontrollera standardkonfigurationen för NGINX-ingresskontrollant

När du aktiverar tillägget för programdirigering med NGINX skapas en ingresskontroll som kallas default i app-routing-namespace, som är konfigurerad med en offentlig Azure-lastbalanserare. Den ingresskontrollern använder ett ingressklassnamn med webapprouting.kubernetes.azure.com.

Du kan också styra om standardvärdet hämtar en offentlig eller en intern IP-adress, eller om den skapas alls när tillägget aktiveras.

Möjliga konfigurationsalternativ är:

• None: Standard-NGINX-ingresskontrollanten skapas inte och tas inte bort om den redan finns. Du bör ta bort den anpassade standardresursen NginxIngressController manuellt om du vill.
• Internal: Standardingresskontrollanten för NGINX skapas med en intern lastbalanserare. Eventuella anteckningsändringar på den anpassade resursen NginxIngressController för att göra den extern skrivs över.
• External: Standard NGINX-ingresskontrollant skapad med en extern lastbalanserare. Eventuella anteckningsändringar på den anpassade resursen NginxIngressController för att göra den intern skrivs över.
• AnnotationControlled (standard): Standardingresskontrollanten för NGINX skapas med en extern lastbalanserare. Du kan redigera den anpassade standardresursen NginxIngressController för att konfigurera anteckningar för lastbalanserare.)

Kontrollera standardkonfigurationen för ingresskontrollant i ett nytt kluster

Uppdatera standardkonfigurationen för ingresskontrollant i ett befintligt kluster

Skapa en annan offentlig NGINX-ingresskontroller

1. Kopiera följande YAML-manifest till en ny fil med namnet nginx-public-controller.yaml och spara filen på den lokala datorn.

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

2. Skapa NGINX-ingresskontrollantresurserna kubectl apply med kommandot .

   kubectl apply -f nginx-public-controller.yaml
   

   Följande exempelutdata visar den skapade resursen:

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

Skapa en intern NGINX-ingresskontrollant med en privat IP-adress

1. Kopiera följande YAML-manifest till en ny fil med namnet nginx-internal-controller.yaml och spara filen på den lokala datorn.

   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. Skapa NGINX-ingresskontrollantresurserna kubectl apply med kommandot .

   kubectl apply -f nginx-internal-controller.yaml
   

   Följande exempelutdata visar den skapade resursen:

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

Skapa en NGINX-ingresskontrollant med en statisk IP-adress

1. Skapa en Azure-resursgrupp med kommandot az group create .

   az group create --name $NETWORK_RESOURCE_GROUP --location $LOCATION
   

2. Skapa en statisk offentlig IP-adress med kommandot az network public ip create .

   az network public-ip create \
     --resource-group $NETWORK_RESOURCE_GROUP \
     --name $PUBLIC_IP_NAME \
     --sku Standard \
     --allocation-method static
   

   Anmärkning

   Om du använder en Basic SKU-lastbalanserare i AKS-klustret, använd Basic parametern --sku när du definierar en offentlig IP-adress. Endast Basic SKU-IP-adresser fungerar med Basic SKU-lastbalanseraren och endast Standard SKU-IP-adresser fungerar med Standard SKU-lastbalanserare.

3. Kontrollera att klusteridentiteten som används av AKS-klustret har delegerade behörigheter till den offentliga IP-adressens resursgrupp med hjälp av az role assignment create kommandot .

   CLIENT_ID=$(az aks show --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --query identity.principalId -o tsv)
   RG_SCOPE=$(az group show --name $NETWORK_RESOURCE_GROUP --query id -o tsv)
   az role assignment create \
     --assignee ${CLIENT_ID} \
     --role "Network Contributor" \
     --scope ${RG_SCOPE}
   

4. Kopiera följande YAML-manifest till en ny fil med namnet nginx-staticip-controller.yaml och spara filen på den lokala datorn.

   Anmärkning

   Du kan antingen använda service.beta.kubernetes.io/azure-pip-name för offentligt IP-namn eller använda service.beta.kubernetes.io/azure-load-balancer-ipv4 för en IPv4-adress och service.beta.kubernetes.io/azure-load-balancer-ipv6 för en IPv6-adress, som du ser i exemplet YAML. Genom att lägga till kommentaren service.beta.kubernetes.io/azure-pip-name säkerställer du att den mest effektiva lastbalanseraren skapas och det rekommenderas starkt för att undvika potentiella begränsningar.

   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: "$PUBLIC_IP_NAME"
       service.beta.kubernetes.io/azure-load-balancer-resource-group: "$NETWORK_RESOURCE_GROUP"
   

5. Skapa NGINX-ingresskontrollantresurserna kubectl apply med kommandot .

   kubectl apply -f nginx-staticip-controller.yaml
   

   Följande exempelutdata visar den skapade resursen:

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

Kontrollera att ingresskontrollanten har skapats

• Kontrollera statusen för NGINX-ingresskontrollanten kubectl get nginxingresscontroller med hjälp av kommandot .

  kubectl get nginxingresscontroller --name $INGRESS_CONTROLLER_NAME
  

  Följande exempelutdata visar den skapade resursen. Det kan ta några minuter innan kontrollanten är tillgänglig:

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

Visa villkoren för ingresskontrollanten

• Visa villkoren för ingresskontrollanten för att felsöka eventuella problem med hjälp av kubectl get nginxingresscontroller kommandot.

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

  Följande exempelutdata visar villkoren för en felfri ingresskontrollant:

  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
  

Använd ingresskontrollanten i en ingress

1. Kopiera följande YAML-manifest till en ny fil med namnet ingress.yaml och spara filen på den lokala datorn.

   Anmärkning

   Uppdatera <HostName> med DNS-värdnamnet. <IngressClassName> är den som du definierade när du skapade NginxIngressController.

   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. Skapa klusterresurserna kubectl apply med kommandot .

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

   Följande exempelutdata visar den skapade resursen:

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

Verifiera att den hanterade ingressen har skapats

• Kontrollera att den hanterade ingressen kubectl get ingress skapades med kommandot .

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

  Dina utdata bör likna följande exempelutdata:

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

Ta bort ingresskontrollanter

• Ta bort NGINX-ingresskontrollanten kubectl delete nginxingresscontroller med kommandot .

  kubectl delete nginxingresscontroller --name $INGRESS_CONTROLLER_NAME
  

Konfiguration per ingressresurs via anteckningar

NGINX-ingresskontrollanten har stöd för att lägga till anteckningar till specifika ingressobjekt för att anpassa deras beteende.

Du kan kommentera ingressobjektet genom att lägga till respektive anteckning i fältet metadata.annotations .

Följande avsnitt innehåller exempel på vanliga konfigurationer. En fullständig lista finns i dokumentationen om NGINX-ingressanteckningar.

Anpassningsbar maximal kroppsstorlek

För NGINX returneras ett 413-fel till klienten när storleken i en begäran överskrider den maximala tillåtna storleken på klientbegärandetexten. Om du vill åsidosätta standardvärdet använder du kommentaren:

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

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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

Tidsgräns för anpassad anslutning

Du kan ändra tidsgränsen som NGINX-ingresskontrollern väntar innan den stänger en anslutning till din arbetsbelastning. Alla timeout-värden är enhetslösa och i sekunder. Om du vill åsidosätta standardtimeouten använder du följande kommentar för att ange en giltig tidsgräns för 120 sekunders proxyläsning:

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

Granska anpassade tidsgränser för andra konfigurationsalternativ.

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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

Backend-protokoll

NGINX-ingresskontrollanten använder HTTP för att nå tjänsterna som standard. Om du vill konfigurera alternativa serverdelsprotokoll som HTTPS eller GRPCanvänder du någon av följande anteckningar:

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

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

Granska serverdelsprotokollen för andra konfigurationsalternativ.

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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

Resursdelning med flera ursprung (CORS)

Om du vill aktivera resursdelning mellan ursprung (CORS) i en ingressregel använder du följande kommentar:

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

Läs aktivera CORS för andra konfigurationsalternativ.

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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

Inaktivera SSL-omdirigering

Kontrollanten omdirigerar (308) till HTTPS om TLS är aktiverat för en ingress som standard. Om du vill inaktivera den här funktionen för specifika ingressresurser använder du följande kommentar:

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

Granska HTTPS-tillämpningen på serversidan genom omdirigering för andra konfigurationsalternativ.

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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-omskrivning

I vissa scenarier skiljer sig den exponerade URL:en i serverdelstjänsten från den angivna sökvägen i ingressregeln. Utan en omskrivning returnerar varje begäran en 404. Den här konfigurationen är användbar med sökvägsbaserad routning där du kan hantera två olika webbprogram under samma domän. Du kan ange sökvägen som förväntas av tjänsten med hjälp av följande kommentar:

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

Här är ett exempel på en ingresskonfiguration med den här kommentaren:

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

Uppdatering av NGINX-hälsoavsökningssökväg

Standardsökvägen för hälsokontroll för Azure Load Balancer som är associerad med NGINX-ingresskontrollern måste vara inställd på "/healthz". För att säkerställa korrekta hälsokontroller, kontrollera att ingresskontrolltjänsten har följande annotering:

metadata:
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path: "/healthz"

Om du använder Helm för att hantera din NGINX-ingresskontrollant kan du definiera hälsoavsökningsanteckningen för Azure Load Balancer i en värdefil och tillämpa den under en uppgradering:

controller:
  service:
    annotations:
      service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path: "/healthz"

Den här konfigurationen hjälper till att upprätthålla tjänstens tillgänglighet och undviker oväntade trafikstörningar under uppgraderingar.