Skapa en HTTPS-ingresskontrollant Azure Kubernetes Service (AKS)

  • Artikel
  • 13 minuter för att läsa

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. Med hjälp av en ingress-kontrollant och ingress-regler 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 Azure Kubernetes Service-kluster (AKS). Cert-Manager-projektet används för att automatiskt generera och konfigurera Let's Encrypt-certifikat. Slutligen körs två program i AKS-klustret, som var och en kan nås via en enda IP-adress.

Du kan även:

Innan du börjar

Den här artikeln förutsätter att du har ett befintligt AKS-kluster. Om du behöver ett AKS-kluster kan du gå till AKS-snabbstarten med hjälp av Azure CLI, använda Azure PowerShell eller använda Azure Portal.

Den här artikeln förutsätter också att du har en anpassad domän med en DNS-zon i samma resursgrupp som ditt AKS-kluster.

Den här artikeln använder Helm 3 för att installera NGINX-indatakontrollanten på en version av Kubernetes som stöds. Kontrollera att du använder den senaste versionen av Helm och har åtkomst till ingress-nginx jetstack Helm-lagringsplatsen och . Stegen som beskrivs i den här artikeln kanske inte är kompatibla med tidigare versioner av Helm-diagrammet, NGINX-indatakontrollanten eller Kubernetes.

Mer information om hur du konfigurerar och använder Helm finns i Installera program med Helm i Azure Kubernetes Service (AKS). Uppgraderingsanvisningar finns i installationsdokumenten för Helm.

Dessutom förutsätter den här artikeln att du har ett befintligt AKS-kluster med ett integrerat ACR. Mer information om hur du skapar ett AKS-kluster med ett integrerat ACR finns i Autentisera med Azure Container Registry från Azure Kubernetes Service.

Den här artikeln kräver också 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.

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

I den här artikeln används Helm-diagrammet för NGINX-inresskontrollanten,som förlitar sig på tre containeravbildningar.

Använd az acr import för att importera avbildningarna till ACR.

REGISTRY_NAME=<REGISTRY_NAME>
SOURCE_REGISTRY=k8s.gcr.io
CONTROLLER_IMAGE=ingress-nginx/controller
CONTROLLER_TAG=v1.0.4
PATCH_IMAGE=ingress-nginx/kube-webhook-certgen
PATCH_TAG=v1.1.1
DEFAULTBACKEND_IMAGE=defaultbackend-amd64
DEFAULTBACKEND_TAG=1.5
CERT_MANAGER_REGISTRY=quay.io
CERT_MANAGER_TAG=v1.5.4
CERT_MANAGER_IMAGE_CONTROLLER=jetstack/cert-manager-controller
CERT_MANAGER_IMAGE_WEBHOOK=jetstack/cert-manager-webhook
CERT_MANAGER_IMAGE_CAINJECTOR=jetstack/cert-manager-cainjector

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
az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_CONTROLLER:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_CONTROLLER:$CERT_MANAGER_TAG
az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_WEBHOOK:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_WEBHOOK:$CERT_MANAGER_TAG
az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_CAINJECTOR:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_CAINJECTOR:$CERT_MANAGER_TAG

Anteckning

Förutom att importera containeravbildningar till ACR kan du också importera Helm-diagram till ACR. Mer information finns i Push and pull Helm charts to an Azure container registry (Skicka och hämta Helm-diagram till ett Azure-containerregister).

Skapa en ingress-kontrollant

Om du vill skapa ingress-kontrollanten använder helm du kommandot för att installera nginx-ingress. 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 ingress-kontrollanten kontrollerar du att det finns fler än en nod i ditt AKS-kluster.

Ingresskontrollanten måste också 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.

Tips

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.

Tips

Om du vill aktivera bevarande av klientkällans IP-adress för begäranden till containrar i klustret lägger du --set controller.service.externalTrafficPolicy=Local till i installationskommandot för Helm. Klientens käll-IP lagras i begärandehuvudet under X-Forwarded-For. När du använder en ingress-kontrollant med klientkällans IP-bevarande aktiverat fungerar inte TLS-genomgående.

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

# Set variable for ACR location to use for pulling images
ACR_URL=<REGISTRY_URL>

# Use Helm to deploy an NGINX ingress controller
helm install nginx-ingress ingress-nginx/ingress-nginx \
    --namespace ingress-basic --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_URL \
    --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.admissionWebhooks.patch.image.registry=$ACR_URL \
    --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_URL \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Under installationen skapas en offentlig IP-adress i Azure för ingress-kontrollanten. Den här offentliga IP-adressen är statisk för ingress-kontrollantens livslängd. Om du tar bort ingress-kontrollanten går tilldelningen av den offentliga IP-adressen förlorad. Om du sedan skapar ytterligare en ingress-kontrollant tilldelas en ny offentlig IP-adress. Om du vill behålla användningen av den offentliga IP-adressen kan du i stället skapa en ingress-kontrollant med en statisk offentlig IP-adress.

Hämta den offentliga IP-adressen med kubectl get service kommandot . Det tar några minuter för IP-adressen att tilldelas till tjänsten.

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

NAME                                     TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
nginx-ingress-ingress-nginx-controller   LoadBalancer   10.0.74.133   EXTERNAL_IP     80:32486/TCP,443:30953/TCP   44s   app.kubernetes.io/component=controller,app.kubernetes.io/instance=nginx-ingress,app.kubernetes.io/name=ingress-nginx

Inga inkommande regler har skapats ännu. Om du bläddrar till den offentliga IP-adressen visas NGINX-ingresskontrollantens standardsida 404.

Lägga till en A-post i DNS-zonen

Lägg till en A-post i DNS-zonen med den externa IP-adressen för NGINX-tjänsten med az network dns record-set a add-record.

az network dns record-set a add-record \
    --resource-group myResourceGroup \
    --zone-name MY_CUSTOM_DOMAIN \
    --record-set-name "*" \
    --ipv4-address MY_EXTERNAL_IP

Konfigurera ett FQDN för ingress-kontrollanten

Du kan också konfigurera ett FQDN för ingress-kontrollantens IP-adress i stället för en anpassad domän. Ditt FQDN har formuläret <CUSTOM LABEL>.<AZURE REGION NAME>.cloudapp.azure.com .

Det finns två metoder för den här konfigurationen som beskrivs nedan.

Metod 1: Ange DNS-etiketten med hjälp av Azure CLI

Observera att det här exemplet är för ett Bash-gränssnitt.

# Public IP address of your ingress controller
IP="MY_EXTERNAL_IP"

# Name to associate with public IP address
DNSNAME="demo-aks-ingress"

# Get the resource-id of the public ip
PUBLICIPID=$(az network public-ip list --query "[?ipAddress!=null]|[?contains(ipAddress, '$IP')].[id]" --output tsv)

# Update public ip address with DNS name
az network public-ip update --ids $PUBLICIPID --dns-name $DNSNAME

# Display the FQDN
az network public-ip show --ids $PUBLICIPID --query "[dnsSettings.fqdn]" --output tsv

Metod 2: Ange DNS-etiketten med helm-diagraminställningar

Du kan skicka en kommentarsinställning till helm-diagramkonfigurationen med hjälp av --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" parametern . Detta kan anges antingen när ingress-kontrollanten först distribueras eller så kan den konfigureras senare. I följande exempel visas hur du uppdaterar den här inställningen när kontrollanten har distribuerats.

DNS_LABEL="demo-aks-ingress"
NAMESPACE="nginx-basic"

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNS_LABEL

Installera cert-manager

NGINX-ingresskontrollanten stöder TLS-avslutning. Det finns flera sätt att hämta och konfigurera certifikat för HTTPS. Den här artikeln visar hur du använder cert-manager, som tillhandahåller automatisk Låter kryptera certifikatgenerering och hanteringsfunktioner.

Så här installerar du cert-manager-styrenheten:

# Label the ingress-basic namespace to disable resource validation
kubectl label namespace ingress-basic cert-manager.io/disable-validation=true

# Add the Jetstack Helm repository
helm repo add jetstack https://charts.jetstack.io

# Update your local Helm chart repository cache
helm repo update

# Install the cert-manager Helm chart
helm install cert-manager jetstack/cert-manager \
  --namespace ingress-basic \
  --version $CERT_MANAGER_TAG \
  --set installCRDs=true \
  --set nodeSelector."kubernetes\.io/os"=linux \
  --set image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_CONTROLLER \
  --set image.tag=$CERT_MANAGER_TAG \
  --set webhook.image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_WEBHOOK \
  --set webhook.image.tag=$CERT_MANAGER_TAG \
  --set cainjector.image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_CAINJECTOR \
  --set cainjector.image.tag=$CERT_MANAGER_TAG

Mer information om konfiguration av cert-manager finns i cert-manager-projektet.

Skapa en CA-klusterutfärdare

Innan certifikat kan utfärdas kräver cert-manager en Issuer- eller ClusterIssuer-resurs. Dessa Kubernetes-resurser är identiska i funktioner, men fungerar i ett enda Issuer namnområde ClusterIssuer och fungerar i alla namnområden. Mer information finns i dokumentationen om cert-manager issuer.

Skapa en klusterutfärdare, till exempel cluster-issuer.yaml , med hjälp av följande exempelmanifest. Uppdatera e-postadressen med en giltig adress från din organisation:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: MY_EMAIL_ADDRESS
    privateKeySecretRef:
      name: letsencrypt
    solvers:
    - http01:
        ingress:
          class: nginx
          podTemplate:
            spec:
              nodeSelector:
                "kubernetes.io/os": linux

Använd kommandot för att skapa kubectl apply utfärdaren.

kubectl apply -f cluster-issuer.yaml

Köra demoprogram

En ingress-kontrollant och en certifikathanteringslösning har konfigurerats. Nu ska vi köra två demoprogram i ditt AKS-kluster. I det här exemplet används Helm för att distribuera två instanser av ett enkelt Hello World-program.

Om du vill se hur ingress-kontrollanten används kör du två demoprogram i ditt AKS-kluster. I det här exemplet använder du kubectl apply för att distribuera två instanser av ett enkelt Hello World-program.

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

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

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

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

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. De är dock konfigurerade med en tjänst av ClusterIP typen och är inte tillgängliga från Internet. Om du vill göra dem offentligt tillgängliga skapar du en Kubernetes-ingressresurs. Ingressresursen konfigurerar reglerna som dirigerar trafik till ett av de två programmen.

I följande exempel trafik till adressen hello-world-ingress. MY_CUSTOM_DOMAIN dirigeras till tjänsten aks-helloworld-one. Trafik till adressen hello-world-ingress. MY_CUSTOM_DOMAIN/hello-world-two dirigeras till tjänsten aks-helloworld-two. Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN/static dirigeras till tjänsten aks-helloworld-one för statiska tillgångar.

Anteckning

Om du har konfigurerat ett FQDN för ingress-kontrollantens IP-adress i stället för en anpassad domän använder du FQDN i stället för hello-world-ingress. MY_CUSTOM_DOMAIN. Om ditt FQDN till exempel demo-aks-ingress.eastus.cloudapp.azure.com ersätter du hello-world-ingress. MY_CUSTOM_DOMAIN med demo-aks-ingress.eastus.cloudapp.azure.com i hello-world-ingress.yaml .

Skapa en fil med namnet hello-world-ingress.yaml med yaml-exemplet nedan. Uppdatera värdarna och värden till DNS-namnet som du skapade i föregående steg.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/rewrite-target: /$1
    nginx.ingress.kubernetes.io/use-regex: "true"
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  tls:
  - hosts:
    - hello-world-ingress.MY_CUSTOM_DOMAIN
    secretName: tls-secret
  rules:
  - host: hello-world-ingress.MY_CUSTOM_DOMAIN
    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:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/rewrite-target: /static/$2
    nginx.ingress.kubernetes.io/use-regex: "true"
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  tls:
  - hosts:
    - hello-world-ingress.MY_CUSTOM_DOMAIN
    secretName: tls-secret
  rules:
  - host: hello-world-ingress.MY_CUSTOM_DOMAIN
    http:
      paths:
      - path:
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port: 
              number: 80
        path: /static(/|$)(.*)

Skapa ingressresursen med kubectl apply kommandot .

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

Kontrollera att ett certifikatobjekt har skapats

Därefter måste en certifikatresurs skapas. Certifikatresursen definierar det önskade X.509-certifikatet. Mer information finns i cert-manager-certifikat. Cert-manager har automatiskt skapat ett certifikatobjekt åt dig med hjälp av ingress-shim, som distribueras automatiskt med cert-manager sedan v0.2.2. Mer information finns i ingress-shim-dokumentationen.

Kontrollera att certifikatet har skapats genom att använda kommandot kubectl get certificate --namespace ingress-basic och kontrollera att READY är True, vilket kan ta flera minuter.

$ kubectl get certificate --namespace ingress-basic

NAME         READY   SECRET       AGE
tls-secret   True    tls-secret   11m

Testa ingresskonfigurationen

Öppna en webbläsare för hello-world-ingress. MY_CUSTOM_DOMAIN kubernetes-indatakontrollanten. Observera att du omdirigeras för att använda HTTPS och att certifikatet är betrott och att demoprogrammet visas i webbläsaren. Lägg till sökvägen /hello-world-two och lägg märke till att det andra demoprogrammet med den anpassade rubriken visas.

Rensa resurser

Den här artikeln använde Helm för att installera ingresskomponenter, certifikat och exempelappar. När du distribuerar ett Helm-diagram skapas ett antal Kubernetes-resurser. Dessa resurser omfattar poddar, distributioner och tjänster. Om du vill rensa resurserna kan du antingen ta bort hela exempelnamnrymden eller de enskilda resurserna.

Ta bort exempelnamnområdet och alla resurser

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

kubectl delete namespace ingress-basic

Ta bort resurser individuellt

En mer detaljerad metod kan också vara att ta bort de enskilda resurser som skapats. Ta först bort resurserna för klusterutfärdaren:

kubectl delete -f cluster-issuer.yaml --namespace ingress-basic

Visa en lista över Helm-versioner med helm list kommandot . Leta efter diagram med namnet nginx och cert-manager, som du ser i följande exempelutdata:

$ helm list --namespace ingress-basic

NAME                    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
cert-manager            ingress-basic   1               2020-01-15 10:23:36.515514 -0600 CST    deployed        cert-manager-v0.13.0    v0.13.0    
nginx                   ingress-basic   1               2020-01-15 10:09:45.982693 -0600 CST    deployed        nginx-ingress-1.29.1    0.27.0

Avinstallera versionerna med helm uninstall kommandot . I följande exempel avinstalleras NGINX-ingress- och cert-manager-distributionerna.

$ helm uninstall cert-manager nginx --namespace ingress-basic

release "cert-manager" uninstalled
release "nginx" uninstalled

Ta sedan bort de två exempelprogrammen:

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

Ta bort den ingressväg som dirigerade trafik till exempelapparna:

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

Slutligen kan du ta bort själva namnområdet. Använd kommandot kubectl delete och ange namnet på namnområdet:

kubectl delete namespace ingress-basic

Nästa steg

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

Du kan även: