Dela via

Skapa en ohanterad ingresskontrollant

  • Artikel

En ingress-kontrollant är en del av programvaran som tillhandahåller omvänd proxy, konfigurerbar trafikroutning och TLS-Avslut för Kubernetes-tjänster. Kubernetes ingress-resurser används för att konfigurera inkommande regler och vägar för enskilda Kubernetes-tjänster. När du använder en ingångskontrollant och ingångsregler kan en IP-adress användas för att dirigera trafik till flera tjänster i ett Kubernetes-kluster.

Den här artikeln visar hur du distribuerar NGINX-ingresskontrollanten i ett AKS-kluster (Azure Kubernetes Service). Två program körs sedan i AKS-klustret, som var och en är tillgänglig via den enskilda IP-adressen.

Viktigt!

Tillägget Programroutning rekommenderas för ingress i AKS. Mer information finns i Hanterad nginx-ingress med tillägget för programroutning.

Kommentar

Det finns två öppen källkod ingresskontrollanter för Kubernetes baserat på Nginx: en underhålls av Kubernetes-communityn (kubernetes/ingress-nginx), och en underhålls av NGINX, Inc. (nginxinc/kubernetes-ingress). Den här artikeln kommer att använda Kubernetes community-ingresskontrollant.

Innan du börjar

  • Den här artikeln använder Helm 3 för att installera NGINX-ingresskontrollanten på en version av Kubernetes som stöds. Kontrollera att du använder den senaste versionen av Helm och har åtkomst till Helm-lagringsplatsen ingress-nginx . Stegen som beskrivs i den här artikeln kanske inte är kompatibla med tidigare versioner av Helm-diagrammet, NGINX-ingresskontrollanten eller Kubernetes.
  • Den här artikeln förutsätter att du har ett befintligt AKS-kluster med ett integrerat Azure Container Registry (ACR). Mer information om hur du skapar ett AKS-kluster med en integrerad ACR finns i Autentisera med Azure Container Registry från Azure Kubernetes Service.
  • Kubernetes API-hälsoslutpunkten healthz var inaktuell i Kubernetes v1.16. Du kan ersätta den här slutpunkten med slutpunkterna livez och readyz i stället. Se Kubernetes API-slutpunkter för hälsa för att avgöra vilken slutpunkt som ska användas för ditt scenario.
  • Om du använder Azure CLI kräver den här artikeln att du kör Azure CLI version 2.0.64 eller senare. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa [Installera Azure CLI][azure-cli-install].
  • Om du använder Azure PowerShell kräver den här artikeln att du kör Azure PowerShell version 5.9.0 eller senare. Kör Get-InstalledModule -Name Az för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Install Azure PowerShell (Installera Azure PowerShell).

Standardkonfiguration

Om du vill skapa en grundläggande NGINX-ingresskontrollant utan att anpassa standardinställningarna använder du Helm. I följande konfiguration används standardkonfigurationen för enkelhetens skull. Du kan lägga till parametrar för att anpassa distributionen, till exempel --set controller.replicaCount=3.

Kommentar

Om du vill aktivera IP-bevarande av klientkällan för begäranden till containrar i klustret lägger du till --set controller.service.externalTrafficPolicy=Local i Helm-installationskommandot. Klientkällans IP-adress lagras i begärandehuvudet under X-Forwarded-For. När du använder en ingresskontrollant med ip-konservering av klientkällan aktiverad fungerar inte TLS-direkt.

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

Kommentar

I den här självstudien service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path ställs in på /healthz. Det innebär att om svarskoden för begäranden till /healthz inte 200är , kommer hela ingresskontrollanten att vara nere. Du kan ändra värdet till annan URI i ditt eget scenario. Du kan inte ta bort den här delen eller ta bort värdet, annars är ingresskontrollanten fortfarande nere. Paketet ingress-nginx som används i den här självstudien, som tillhandahålls av Kubernetes-tjänsteman, returnerar 200 alltid svarskod om du begär /healthz, eftersom det är utformat som standardserverdel för användare att få en snabbstart, såvida det inte skrivs över av ingressregler.

Anpassad konfiguration

Som ett alternativ till den grundläggande konfiguration som visas i avsnittet ovan visar nästa uppsättning steg hur du distribuerar en anpassad ingresskontrollant. Du kan välja att använda en intern statisk IP-adress eller använda en dynamisk offentlig IP-adress.

Importera bilderna som används av Helm-diagrammet till din ACR

Om du vill styra avbildningsversioner vill du importera dem till ditt eget Azure Container Registry. Helm-diagrammet för NGINX-ingresskontrollanten förlitar sig på tre containeravbildningar. Använd az acr import för att importera dessa bilder till din ACR.

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

Kommentar

Förutom att importera containeravbildningar till din ACR kan du även importera Helm-diagram till din ACR. Mer information finns i Skicka och hämta Helm-diagram till ett Azure Container Registry.

Skapa en ingresskontrollant

Om du vill skapa ingresskontrollanten använder du Helm för att installera ingress-nginx. Ingresskontrollanten måste schemaläggas på en Linux-nod. Windows Server-noder bör inte köra ingresskontrollanten. En nodväljare anges med parametern --set nodeSelector för att instruera Kubernetes-schemaläggaren att köra NGINX-ingresskontrollanten på en Linux-baserad nod.

För ytterligare redundans distribueras två repliker av NGINX-ingresskontrollanterna med parametern --set controller.replicaCount. Om du vill dra full nytta av att köra repliker av ingresskontrollanten kontrollerar du att det finns fler än en nod i AKS-klustret.

I följande exempel skapas ett Kubernetes-namnområde för ingressresurserna med namnet ingress-basic och är avsett att fungera inom det namnområdet. Ange ett namnområde för din egen miljö efter behov. Om aks-klustret inte är rollbaserad åtkomstkontroll för Kubernetes aktiverad lägger du till --set rbac.create=false i Helm-kommandona.

Kommentar

Om du vill aktivera IP-bevarande av klientkällan för begäranden till containrar i klustret lägger du till --set controller.service.externalTrafficPolicy=Local i Helm-installationskommandot. Klientkällans IP-adress lagras i begärandehuvudet under X-Forwarded-For. När du använder en ingresskontrollant med ip-konservering av klientkällan aktiverad fungerar inte TLS-direkt.

# 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=""

Skapa en ingresskontrollant med hjälp av en intern IP-adress

Som standard skapas en NGINX-ingresskontrollant med en dynamisk offentlig IP-adresstilldelning. Ett vanligt konfigurationskrav är att använda ett internt, privat nätverk och IP-adress. Med den här metoden kan du begränsa åtkomsten till dina tjänster till interna användare, utan extern åtkomst.

Använd parametrarna --set controller.service.loadBalancerIP och --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true för att tilldela en intern IP-adress till ingresskontrollanten. Ange din egen interna IP-adress för användning med ingresskontrollanten. Kontrollera att den här IP-adressen inte redan används i det virtuella nätverket. Om du använder ett befintligt virtuellt nätverk och undernät måste du konfigurera AKS-klustret med rätt behörighet för att hantera det virtuella nätverket och undernätet. Mer information finns i Använda kubenet-nätverk med dina egna IP-adressintervall i Azure Kubernetes Service (AKS) eller Konfigurera Azure CNI-nätverk i 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=""

Kontrollera lastbalanseringstjänsten

Kontrollera lastbalanserarens tjänst med hjälp kubectl get servicesav .

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

När Kubernetes-lastbalanserarens tjänst skapas för NGINX-ingresskontrollanten tilldelas en IP-adress under EXTERNAL-IP, enligt följande exempelutdata:

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

Om du bläddrar till den externa IP-adressen i det här skedet visas en 404-sida. Det beror på att du fortfarande behöver konfigurera anslutningen till den externa IP-adressen, vilket görs i nästa avsnitt.

Köra demoprogram

Om du vill se ingresskontrollanten i praktiken kör du två demoprogram i AKS-klustret. I det här exemplet använder kubectl apply du för att distribuera två instanser av ett enkelt Hello World-program .

  1. Skapa en aks-helloworld-one.yaml fil och kopiera i följande exempel YAML:

    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. Skapa en aks-helloworld-two.yaml fil och kopiera i följande exempel YAML:

    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. Kör de två demoprogrammen med :kubectl apply

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

Skapa en ingressväg

Båda programmen körs nu i kubernetes-klustret. Om du vill dirigera trafik till varje program skapar du en Kubernetes-ingressresurs. Ingressresursen konfigurerar de regler som dirigerar trafik till ett av de två programmen.

I följande exempel dirigeras trafik till EXTERNAL_IP/hello-world-one till tjänsten med namnet aks-helloworld-one. Trafik till EXTERNAL_IP/hello-world-two dirigeras till tjänsten aks-helloworld-two . Trafik till EXTERNAL_IP/statisk dirigeras till tjänsten med namnet aks-helloworld-one för statiska tillgångar.

  1. Skapa en fil med namnet hello-world-ingress.yaml och kopiera i följande exempel YAML:

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

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

Testa ingresskontrollanten

Om du vill testa vägarna för ingresskontrollanten bläddrar du till de två programmen. Öppna en webbläsare till IP-adressen för din NGINX-ingresskontrollant, till exempel EXTERNAL_IP. Det första demoprogrammet visas i webbläsaren, som du ser i följande exempel:

En skärmbild som visar den första appen som körs bakom ingresskontrollanten.

Lägg nu till sökvägen /hello-world-two till IP-adressen, till exempel EXTERNAL_IP/hello-world-two. Det andra demoprogrammet med den anpassade rubriken visas:

En skärmbild som visar den andra appen som körs bakom ingresskontrollanten.

Testa en intern IP-adress

  1. Skapa en testpodd och bifoga en terminalsession till den.

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

  2. Installera curl i podden med .apt-get

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

  3. Få åtkomst till adressen för din Kubernetes-ingresskontrollant med hjälp av curl, till exempel http://10.224.0.42. Ange din egen interna IP-adress som angavs när du distribuerade ingresskontrollanten.

    curl -L http://10.224.0.42

    Ingen sökväg angavs med adressen, så ingresskontrollanten är standard för / vägen. Det första demoprogrammet returneras, enligt följande komprimerade exempelutdata:

    <!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. Lägg till sökvägen /hello-world-two till adressen, till exempel http://10.224.0.42/hello-world-two.

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

    Det andra demoprogrammet med den anpassade rubriken returneras, enligt följande komprimerade exempelutdata:

    <!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>
[...]

Rensa resurser

Den här artikeln använde Helm för att installera ingresskomponenterna och exempelapparna. När du distribuerar ett Helm-diagram skapas många Kubernetes-resurser. Dessa resurser omfattar poddar, distributioner och tjänster. Om du vill rensa dessa resurser kan du antingen ta bort hela exempelnamnområdet eller de enskilda resurserna.

Ta bort exempelnamnområdet och alla resurser

Om du vill ta bort hela exempelnamnområdet använder du kubectl delete kommandot och anger namnet på ditt namnområde. Alla resurser i namnområdet tas bort.

kubectl delete namespace ingress-basic

Ta bort resurser individuellt

Alternativt är en mer detaljerad metod att ta bort de enskilda resurser som skapats.

  1. Visa en lista över Helm-versionerna helm list med kommandot .

    helm list --namespace ingress-basic

    Leta efter diagram med namnet ingress-nginx och aks-helloworld, som du ser i följande exempelutdata:

    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. Avinstallera versionerna med helm uninstall kommandot .

    helm uninstall ingress-nginx --namespace ingress-basic

  3. Ta bort de två exempelprogrammen.

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

  4. Ta bort den inkommande vägen som dirigerade trafik till exempelapparna.

    kubectl delete -f hello-world-ingress.yaml

  5. Ta bort namnområdet med kommandot kubectl delete och ange namnområdesnamnet.

    kubectl delete namespace ingress-basic

Nästa steg

Information om hur du konfigurerar TLS med dina befintliga ingresskomponenter finns i Använda TLS med en ingresskontrollant.

Information om hur du konfigurerar AKS-klustret att använda HTTP-programroutning finns i Aktivera tillägget HTTP-programroutning.

Den här artikeln innehåller några externa komponenter till AKS. Mer information om dessa komponenter finns på följande projektsidor:

Kontakta oss för att få hjälp

Om du har frågor eller behöver hjälp skapar du en supportförfrågan eller frågar Azure community support. Du kan också skicka produktfeedback till Azure-feedbackcommunityn.