Een HTTPS-controller voor Azure Kubernetes Service (AKS) maken

  • Artikel
  • 15 minuten om te lezen

Een controller voor inkomend verkeer is een stukje software dat omgekeerde proxy’s, configureerbare verkeersroutering en TLS-beëindiging voor Kubernetes-services biedt. Kubernetes-resources voor inkomend verkeer worden gebruikt om de regels en routes voor uitgaand verkeer worden geconfigureerd voor individuele Kubernetes-services. Met behulp van een controller en regels voor inkomend verkeer kan er één enkel IP-adres worden gebruikt voor het routeren van verkeer naar meerdere services in een Kubernetes-cluster.

In dit artikel wordt beschreven hoe u de NGINX-controller voor een Azure Kubernetes Service (AKS) implementeert. Het certificaatbeheerproject wordt gebruikt voor het automatisch genereren en configureren van Let's Encrypt-certificaten. Ten slotte worden er twee toepassingen uitgevoerd in het AKS-cluster, die allemaal toegankelijk zijn via één IP-adres.

U kunt ook het volgende doen:

Voordat u begint

In dit artikel wordt ervan uitgenomen dat u een bestaand AKS-cluster hebt. Als u een AKS-cluster nodig hebt, bekijkt u de AKS-quickstart met behulp van de Azure CLI,met behulp van Azure PowerShell of met behulp van de Azure Portal.

In dit artikel wordt ook ervan uitgenomen dat u een aangepast domein hebt met een DNS-zone in dezelfde resourcegroep als uw AKS-cluster.

In dit artikel wordt Helm 3 gebruikt om de NGINX-controller voor ingress te installeren op een ondersteunde versie van Kubernetes. Zorg ervoor dat u de nieuwste versie van Helm gebruikt en toegang hebt tot de ingress-nginx jetstack Helm-opslagplaatsen en . De stappen die in dit artikel worden beschreven, zijn mogelijk niet compatibel met eerdere versies van de Helm-grafiek, NGINX-controller voor ingress of Kubernetes.

Zie Toepassingen installeren met Helm in Azure Kubernetes Service (AKS) voormeer informatie over het configureren en gebruiken van Helm. Zie de helm-installatie docs voor upgrade-instructies.

Bovendien wordt in dit artikel ervan uitgenomen dat u een bestaand AKS-cluster met een geïntegreerde ACR hebt. Zie Verifiëren met ACR voor meer informatie over het maken van een AKS-cluster met een geïntegreerde ACR Azure Container Registry van Azure Kubernetes Service.

Voor dit artikel moet u ook Azure CLI versie 2.0.64 of hoger uitvoeren. Voer az --version uit om de versie te bekijken. Zie Azure CLI installeren als u de CLI wilt installeren of een upgrade wilt uitvoeren.

De afbeeldingen importeren die door de Helm-grafiek worden gebruikt in uw ACR

In dit artikel wordt gebruikgemaakt van de Helm-grafiek voor de NGINX-ingress controller,die afhankelijk is van drie containerafbeeldingen.

Gebruik az acr import om deze afbeeldingen te importeren in uw 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

Notitie

Naast het importeren van containerafbeeldingen in uw ACR, kunt u ook Helm-grafieken in uw ACR importeren. Zie Push and pull Helm charts to an Azure container registry (Helm-grafieken pushen en pullen naar een Azure-containerregister) voor meer informatie.

Een controller voor ingress maken

Gebruik de opdracht om helm nginx-ingress te installeren om de controller voor ingress te maken. Voor toegevoegde redundantie worden er twee replica's van de NGINX-ingangscontrollers geïmplementeerd met de parameter --set controller.replicaCount. Zorg ervoor dat uw AKS-cluster meer dan één knooppunt heeft om volledig te profiteren van het uitvoeren van replica's van de controller voor ingress.

De ingangscontroller moet ook worden gepland op een Linux-knooppunt. Windows Server-knooppunten mogen de ingangscontroller niet uitvoeren. Er wordt een knooppuntselector opgegeven met behulp van de parameter --set nodeSelector om de Kubernetes-planner te laten weten dat de NGINX-ingangscontroller moet worden uitgevoerd op een Linux-knooppunt.

Tip

In het volgende voorbeeld wordt een Kubernetes-naamruimte gemaakt voor de ingress-resources met de naam ingress-basic en is bedoeld om te werken binnen die naamruimte. Geef waar nodig een naamruimte op voor uw eigen omgeving.

Tip

Als u behoud van ip-adressen van clientbron wilt inschakelen voor aanvragen naar containers in uw cluster, voegt u toe --set controller.service.externalTrafficPolicy=Local aan de Helm-installatieopdracht. Het ip-adres van de clientbron wordt opgeslagen in de aanvraagheader onder X-Forwarded-For. Wanneer u een toegangscontroller gebruikt waarop behoud van ip-adressen van clientbron is ingeschakeld, werkt TLS-pass-through niet.

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

Tijdens de installatie wordt een openbaar IP-adres van Azure gemaakt voor de controller voor het binnen- en weer gaan. Dit openbare IP-adres is statisch voor de levensduur van de controller voor ingress. Als u de controller voor ingress verwijdert, gaat de toewijzing van het openbare IP-adres verloren. Als u vervolgens een extra controller voor ingress maakt, wordt er een nieuw openbaar IP-adres toegewezen. Als u het gebruik van het openbare IP-adres wilt behouden, kunt u in plaats daarvan een controller voor binnengangen met een statisch openbaar IP-adres maken.

Gebruik de opdracht om het openbare IP-adres op kubectl get service te halen. Het duurt enkele minuten voordat het IP-adres is toegewezen aan de service.

$ 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

Er zijn nog geen regels voor ingress gemaakt. Als u naar het openbare IP-adres bladert, wordt de standaardpagina 404 van de NGINX-ingresscontroller weergegeven.

Een A-record toevoegen aan uw DNS-zone

Voeg een A-record toe aan uw DNS-zone met het externe IP-adres van de NGINX-service met 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

Een FQDN configureren voor de controller voor ingress

Optioneel kunt u een FQDN configureren voor het IP-adres van de controller voor ingress in plaats van een aangepast domein. Uw FQDN heeft de vorm <CUSTOM LABEL>.<AZURE REGION NAME>.cloudapp.azure.com .

Er zijn twee methoden voor deze configuratie die hieronder worden beschreven.

Methode 1: het DNS-label instellen met behulp van de Azure CLI

Dit voorbeeld is voor een Bash-shell.

# 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

Methode 2: het DNS-label instellen met behulp van helm-grafiekinstellingen

U kunt een aantekeninginstelling doorgeven aan uw Helm-grafiekconfiguratie met behulp van de --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" parameter . Dit kan worden ingesteld wanneer de controller voor het eerst wordt geïmplementeerd of later worden geconfigureerd. In het volgende voorbeeld ziet u hoe u deze instelling bij kunt werken nadat de controller is geïmplementeerd.

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

Certificaatbeheer installeren

De NGINX-ingangscontroller ondersteunt TLS-beëindiging. Er zijn verschillende manieren om certificaten voor HTTPS op te halen en te configureren. In dit artikel wordt gedemonstreerd hoe u certificaatbeheer gebruikt.Dit biedt automatische functionaliteit voor het genereren en beheren van Certificaten versleutelen.

De certificaatbeheercontroller installeren:

# 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

Zie het certificaatbeheerproject voor meer informatie over de configuratie van certificaatbeheer.

Een CA-clustervergever maken

Voordat certificaten kunnen worden uitgegeven, is voor certificaatbeheer een issuer- of ClusterIssuer-resource vereist. Deze Kubernetes-resources zijn identiek qua functionaliteit, maar werken in één naamruimte en werken Issuer ClusterIssuer in alle naamruimten. Zie de documentatie voor certificaatbeheerder voor meer informatie.

Maak een clustervergever, zoals cluster-issuer.yaml , met behulp van het volgende voorbeeldmanifest. Werk het e-mailadres bij met een geldig adres van uw organisatie:

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

Gebruik de opdracht om de vergever te kubectl apply maken.

kubectl apply -f cluster-issuer.yaml

Demotoepassingen uitvoeren

Er zijn een controller voor ingress en een oplossing voor certificaatbeheer geconfigureerd. We gaan nu twee demotoepassingen uitvoeren in uw AKS-cluster. In dit voorbeeld wordt Helm gebruikt om twee exemplaren van een eenvoudige Hallo wereld-toepassing te implementeren.

Als u de controller voor ingress in actie wilt zien, moet u twee demotoepassingen uitvoeren in uw AKS-cluster. In dit voorbeeld gebruikt u om twee exemplaren van een eenvoudige kubectl apply Hallo wereld-toepassing te implementeren.

Maak een aks-helloworld-one.yaml-bestand en kopieer het in het volgende yaml-voorbeeld:

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

Maak een aks-helloworld-two.yaml-bestand en kopieer het in het volgende yaml-voorbeeld:

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

Voer de twee demotoepassingen uit met kubectl apply behulp van :

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

Een route voor ingress maken

Beide toepassingen worden nu uitgevoerd op uw Kubernetes-cluster. Ze zijn echter geconfigureerd met een service van het type ClusterIP en zijn niet toegankelijk vanaf internet. Als u deze openbaar beschikbaar wilt maken, maakt u een Kubernetes-ingress-resource. De resource voor binnenverkeer configureert de regels die verkeer naar een van de twee toepassingen doors groeperen.

In het volgende voorbeeld wordt verkeer naar het adres hello-world-ingress gebruikt. MY_CUSTOM_DOMAIN wordt doorgeleid naar de service aks-helloworld-one. Verkeer naar het adres hello-world-ingress. MY_CUSTOM_DOMAIN/hello-world-two wordt doorgeleid naar de service aks-helloworld-two. Verkeer naar hello-world-ingress. MY_CUSTOM_DOMAIN/static wordt doorgeleid naar de service met de naam aks-helloworld-one voor statische assets.

Notitie

Als u een FQDN hebt geconfigureerd voor het IP-adres van de ingress-controller in plaats van een aangepast domein, gebruikt u de FQDN in plaats van hello-world-ingress. MY_CUSTOM_DOMAIN. Als uw FQDN bijvoorbeeld is demo-aks-ingress.eastus.cloudapp.azure.com, vervangt u hello-world-ingress. MY_CUSTOM_DOMAIN met demo-aks-ingress.eastus.cloudapp.azure.com in hello-world-ingress.yaml .

Maak een bestand met de hello-world-ingress.yaml naam met behulp van het onderstaande YAML-voorbeeld. Werk de hosts en host bij naar de DNS-naam die u in een vorige stap hebt gemaakt.

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(/|$)(.*)

Maak de ingress-resource met behulp van de kubectl apply opdracht .

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

Controleren of er een certificaatobject is gemaakt

Vervolgens moet er een certificaatresource worden gemaakt. De certificaatresource definieert het gewenste X.509-certificaat. Zie certificaten voor certificaatbeheer voor meer informatie. Certificaatbeheer heeft automatisch een certificaatobject voor u gemaakt met behulp van de ingress-shim, die automatisch wordt geïmplementeerd met certificaatbeheer sinds v0.2.2. Zie de documentatie voor ingress-shim voor meer informatie.

Als u wilt controleren of het certificaat is gemaakt, gebruikt u de opdracht en controleert u of kubectl get certificate --namespace ingress-basic READY true is. Dit kan enkele minuten duren.

$ kubectl get certificate --namespace ingress-basic

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

De configuratie van het ingress testen

Open een webbrowser om hello-world-ingress te openen. MY_CUSTOM_DOMAIN van uw Kubernetes-controller voor ingress. U wordt omgeleid om HTTPS te gebruiken, het certificaat wordt vertrouwd en de demotoepassing wordt weergegeven in de webbrowser. Voeg het pad /hello-world-two toe en u ziet dat de tweede demotoepassing met de aangepaste titel wordt weergegeven.

Resources opschonen

In dit artikel is Helm gebruikt om de toegangs-onderdelen, certificaten en voorbeeld-apps te installeren. Wanneer u een Helm-grafiek implementeert, wordt er een aantal Kubernetes-resources gemaakt. Deze resources omvatten pods, implementaties en services. Als u deze resources wilt ops schonen, kunt u de volledige voorbeeldnaamruimte of de afzonderlijke resources verwijderen.

De voorbeeldnaamruimte en alle resources verwijderen

Als u de volledige voorbeeldnaamruimte wilt verwijderen, gebruikt u de kubectl delete opdracht en geeft u de naam van uw naamruimte op. Alle resources in de naamruimte worden verwijderd.

kubectl delete namespace ingress-basic

Resources afzonderlijk verwijderen

Een meer gedetailleerde benadering is ook het verwijderen van de afzonderlijke resources die zijn gemaakt. Verwijder eerst de resources van de clustervergever:

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

Vermeld de Helm-releases met de helm list opdracht . Zoek naar grafieken met de naam nginx en certificaatbeheer, zoals wordt weergegeven in de volgende voorbeelduitvoer:

$ 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

Verwijder de releases met de helm uninstall opdracht . In het volgende voorbeeld worden de NGINX-implementaties voor in- en certificaatbeheer verwijderd.

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

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

Verwijder vervolgens de twee voorbeeldtoepassingen:

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

Verwijder de toegangsroute die verkeer naar de voorbeeld-apps heeft geleid:

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

Ten slotte kunt u de naamruimte zelf verwijderen. Gebruik de kubectl delete opdracht en geef de naam van uw naamruimte op:

kubectl delete namespace ingress-basic

Volgende stappen

Dit artikel bevat enkele externe onderdelen voor AKS. Zie de volgende projectpagina's voor meer informatie over deze onderdelen:

U kunt ook het volgende doen: