TLS gebruiken met een ingangscontroller in Azure Kubernetes Service (AKS)

  • Artikel

Het TLS-protocol (Transport Layer Security) maakt gebruik van certificaten om beveiliging te bieden voor communicatie, versleuteling, verificatie en integriteit. Door TLS te gebruiken met een ingangscontroller op AKS, kunt u de communicatie tussen uw toepassingen beveiligen en de voordelen van een ingangscontroller ervaren.

U kunt uw eigen certificaten meenemen en integreren met het stuurprogramma Secrets Store CSI. U kunt ook certificaatbeheer gebruiken, waarmee automatisch certificaten van Let's Encrypt worden gegenereerd en geconfigureerd. Twee toepassingen worden uitgevoerd in het AKS-cluster, die elk toegankelijk zijn via één IP-adres.

Belangrijk

De invoegtoepassing Toepassingsroutering wordt aanbevolen voor inkomend verkeer in AKS. Zie Beheerde nginx-toegangsbeheerobjecten met de invoegtoepassing voor toepassingsroutering voor meer informatie.

Belangrijk

Microsoft beheert of biedt geen ondersteuning voor certificaatbeheer en eventuele problemen die voortvloeien uit het gebruik ervan. Zie de documentatie voor het oplossen van problemen met certificaatbeheer voor problemen met cert-manager.

Er zijn twee opensource-ingangscontrollers voor Kubernetes op basis van Nginx: één wordt onderhouden door de Kubernetes-community (kubernetes/ingress-nginx) en één wordt onderhouden door NGINX, Inc. (nginxinc/kubernetes-ingress). In dit artikel wordt de controller voor inkomend verkeer van de Kubernetes-community gebruikt.

Voordat u begint

  • In dit artikel wordt ervan uitgegaan dat u een ingangscontroller en toepassingen hebt ingesteld. Als u een controller voor inkomend verkeer of voorbeeldtoepassingen nodig hebt, raadpleegt u Een controller voor inkomend verkeer maken.

  • In dit artikel wordt Helm 3 gebruikt om de NGINX-ingangscontroller 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 en jetstack Helm-opslagplaatsen. De stappen die in dit artikel worden beschreven, zijn mogelijk niet compatibel met eerdere versies van de Helm-grafiek, NGINX-ingangscontroller of Kubernetes.

  • In dit artikel wordt ervan uitgegaan dat u een bestaand AKS-cluster hebt met een geïntegreerd Azure Container Registry (ACR). Zie Verifiëren met ACR vanuit AKS voor meer informatie over het maken van een AKS-cluster met een geïntegreerde ACR.

  • Als u Azure CLI gebruikt, moet u voor dit artikel azure CLI versie 2.0.64 of hoger uitvoeren. Voer az --version uit om de versie te bekijken. Als u Azure CLI 2.0 wilt installeren of upgraden, raadpleegt u Azure CLI 2.0 installeren.

  • Als u Azure PowerShell gebruikt, moet u voor dit artikel Azure PowerShell versie 5.9.0 of hoger gebruiken. Voer Get-InstalledModule -Name Az uit om de versie te bekijken. Als u PowerShell wilt installeren of upgraden, raadpleegt u De Azure PowerShell installeren.

TLS gebruiken met uw eigen certificaten met Secrets Store CSI Driver

Als u TLS wilt gebruiken met uw eigen certificaten met Secrets Store CSI Driver, hebt u een AKS-cluster nodig met het CSI-stuurprogramma Secrets Store geconfigureerd en een Azure Key Vault-exemplaar.

Zie Geheimenarchief CSI-stuurprogramma instellen voor het inschakelen van NGINX-ingangscontroller met TLS voor meer informatie.

TLS gebruiken met Let's Encrypt-certificaten

Als u TLS wilt gebruiken met Let's Encrypt-certificaten , implementeert u certificaatbeheer, dat automatisch certificaten genereert en configureert.

Importeer de certificaatbeheerinstallatiekopieën die door de Helm-grafiek worden gebruikt in uw ACR

  • Gebruik az acr import dit om de volgende afbeeldingen in uw ACR te importeren.

    REGISTRY_NAME=<REGISTRY_NAME>
CERT_MANAGER_REGISTRY=quay.io
CERT_MANAGER_TAG=v1.8.0
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 $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

U kunt Helm-grafieken ook importeren in uw ACR. Zie Helm-grafieken pushen en ophalen naar een ACR voor meer informatie.

Configuratieopties voor toegangsbeheercontroller

U kunt uw NGINX-ingangscontroller configureren met behulp van een statisch openbaar IP-adres of een dynamisch openbaar IP-adres. Als u een aangepast domein gebruikt, moet u een A-record toevoegen aan uw DNS-zone. Als u geen aangepast domein gebruikt, kunt u een FQDN (Fully Qualified Domain Name) configureren voor het IP-adres van de toegangscontroller.

Een statisch of dynamisch openbaar IP-adres maken

Een statisch, openbaar IP-adres gebruiken

U kunt uw ingangscontroller configureren met een statisch openbaar IP-adres. Het statische openbare IP-adres blijft behouden als u de ingangscontroller verwijdert. Het IP-adres blijft niet behouden als u uw AKS-cluster verwijdert.

Wanneer u uw ingangscontroller bijwerken, moet u een parameter doorgeven aan de Helm-release om ervoor te zorgen dat de controllerservice voor inkomend verkeer op de hoogte wordt gesteld van de load balancer die eraan wordt toegewezen. Voor een correcte werking van de HTTPS-certificaten gebruikt u een DNS-label om een FQDN te configureren voor het IP-adres van de ingangscontroller.

  1. Haal de naam van de resourcegroep van het AKS-cluster op met de az aks show opdracht.

    az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv

  2. Maak een openbaar IP-adres met de statische toewijzingsmethode met behulp van de az network public-ip create opdracht. In het volgende voorbeeld wordt een openbaar IP-adres gemaakt met de naam myAKSPublicIP in de resourcegroep van het AKS-cluster die u in de vorige stap hebt verkregen.

    az network public-ip create --resource-group MC_myResourceGroup_myAKSCluster_eastus --name myAKSPublicIP --sku Standard --allocation-method static --query publicIp.ipAddress -o tsv

Notitie

U kunt ook een IP-adres maken in een andere resourcegroep, die u afzonderlijk van uw AKS-cluster kunt beheren. Als u een IP-adres in een andere resourcegroep maakt, controleert u of het volgende waar is:

  • De clusteridentiteit die wordt gebruikt door het AKS-cluster heeft gedelegeerde machtigingen voor de resourcegroep, zoals Inzender voor het netwerk.
  • Voeg de --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-resource-group"="<RESOURCE_GROUP>" parameter toe. Vervang door <RESOURCE_GROUP> de naam van de resourcegroep waarin het IP-adres zich bevindt.

  1. Voeg de --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"="<DNS_LABEL>" parameter toe. Het DNS-label kan worden ingesteld wanneer de ingangscontroller voor het eerst wordt geïmplementeerd of later kan worden geconfigureerd.

  2. Voeg de --set controller.service.loadBalancerIP="<STATIC_IP>" parameter toe. Geef uw eigen openbare IP-adres op dat in de vorige stap is gemaakt.

    DNS_LABEL="<DNS_LABEL>"
NAMESPACE="ingress-basic"
STATIC_IP=<STATIC_IP>

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNS_LABEL \
  --set controller.service.loadBalancerIP=$STATIC_IP \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Zie Een statisch openbaar IP-adres en DNS-label gebruiken met de AKS-load balancer voor meer informatie.

Een dynamisch, openbaar IP-adres gebruiken

Er wordt een openbaar IP-adres van Azure gemaakt voor uw toegangsbeheerobjectcontroller bij het maken. Het openbare IP-adres is statisch voor de levensduur van uw ingangscontroller. Het openbare IP-adres blijft niet behouden als u de ingangscontroller verwijdert. Als u een nieuwe ingangscontroller maakt, krijgt deze een nieuw openbaar IP-adres toegewezen. De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer.

  • Gebruik de kubectl get service opdracht om het openbare IP-adres voor uw toegangsbeheerobjectcontroller op te halen.

    # Get the public IP address for your ingress controller

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

# Sample output

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

Een A-record toevoegen aan uw DNS-zone

Als u een aangepast domein gebruikt, moet u een A-record toevoegen aan uw DNS-zone. Als u geen aangepast domein gebruikt, kunt u het openbare IP-adres configureren met een FQDN.

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

U kunt desgewenst een FQDN configureren voor het IP-adres van de ingangscontroller in plaats van een aangepast domein door een DNS-label in te stellen. Uw FQDN moet dit formulier volgen: <CUSTOM DNS LABEL>.<AZURE REGION NAME>.cloudapp.azure.com.

Belangrijk

Uw DNS-label moet uniek zijn binnen de Azure-locatie.

U kunt uw FQDN configureren met een van de volgende methoden:

  • Stel het DNS-label in met behulp van Azure CLI of Azure PowerShell.
  • Stel het DNS-label in met behulp van Helm-grafiekinstellingen.

Zie DNS-naamlabels voor openbare IP-adressen voor meer informatie.

Het DNS-label instellen met behulp van Azure CLI of Azure PowerShell

Zorg ervoor dat u vervangt door <DNS_LABEL> uw unieke DNS-label.

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

# Name to associate with public IP address
DNSLABEL="<DNS_LABEL>"

# 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 $DNSLABEL

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

Het DNS-label instellen met behulp van Helm-grafiekinstellingen

U kunt een aantekeningsinstelling doorgeven aan uw Helm-grafiekconfiguratie met behulp van de --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" parameter. Deze parameter kan worden ingesteld wanneer de ingangscontroller voor het eerst wordt geïmplementeerd of later kan worden geconfigureerd.

In het volgende voorbeeld ziet u hoe u deze instelling bijwerkt nadat de controller is geïmplementeerd. Zorg ervoor dat u vervangt door <DNS_LABEL> uw unieke DNS-label.

DNSLABEL="<DNS_LABEL>"
NAMESPACE="ingress-basic"

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNSLABEL \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Cert-manager 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 certificaatbeheer gebruikt, dat automatische functionaliteit voor het genereren en beheren van certificaten biedt.

Gebruik de volgende opdrachten om de cert-manager-controller te installeren.

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

# 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-clusteruitgever maken

Voordat certificaten kunnen worden uitgegeven, is voor certificaatbeheer een van de volgende verleners vereist:

Zie de documentatie voor cert-manager issuer voor meer informatie.

  1. Maak een clusteruitgever, zoals cluster-issuer.yamlhet volgende voorbeeldmanifest. Vervang door MY_EMAIL_ADDRESS 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

  2. Pas de verlener toe met behulp van de kubectl apply opdracht.

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

Uw toegangsbeheerroutes bijwerken

U moet uw ingangsroutes bijwerken om verkeer naar uw FQDN of aangepast domein te verwerken.

In het volgende voorbeeld wordt verkeer als volgt gerouteerd:

  • Verkeer naar hallo wereld-inkomend verkeer. MY_CUSTOM_DOMAIN wordt doorgestuurd naar de aks-helloworld-one-service .
  • Verkeer naar hallo wereld-inkomend verkeer. MY_CUSTOM_DOMAIN/hello-world-two wordt doorgestuurd naar de aks-helloworld-two-service .
  • Verkeer naar hallo wereld-inkomend verkeer. MY_CUSTOM_DOMAIN/statisch wordt doorgestuurd 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 ingangscontroller in plaats van een aangepast domein, gebruikt u de FQDN in plaats van hello-world-inkomend verkeer. MY_CUSTOM_DOMAIN.

Als uw FQDN bijvoorbeeld demo-aks-ingress.eastus.cloudapp.azure.com is, vervangt u hello-world-ingress. MY_CUSTOM_DOMAIN met demo-aks-ingress.eastus.cloudapp.azure.com in hello-world-ingress.yaml.

  1. Maak of werk het hello-world-ingress.yaml bestand bij met behulp van het volgende YAML-voorbeeldbestand. Werk de spec.tls.hosts en spec.rules.host de DNS-naam bij die u in een vorige stap hebt gemaakt.

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

  2. Werk de toegangsbeheerobjectresource bij 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 maakt automatisch een certificaatobject voor u met behulp van inkomend-shim, dat automatisch wordt geïmplementeerd met cert-manager sinds v0.2.2. Zie de documentatie voor inkomend verkeer voor meer informatie.

Als u wilt controleren of het certificaat is gemaakt, gebruikt u de kubectl get certificate --namespace ingress-basic opdracht en controleert u of READY waar is. Het kan enkele minuten duren voordat de uitvoer wordt weergegeven.

kubectl get certificate --namespace ingress-basic

In de volgende uitvoer ziet u de status van het certificaat.

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

De configuratie van inkomend verkeer testen

Open een webbrowser om hallo wereld-inkomend verkeer te openen. MY_CUSTOM_DOMAIN of de FQDN van uw Kubernetes-ingangscontroller. Zorg ervoor dat het volgende waar is:

  • U wordt omgeleid om HTTPS te gebruiken.
  • Het certificaat wordt vertrouwd.
  • De demotoepassing wordt weergegeven in de webbrowser.
  • Voeg /hello-world-two toe aan het einde van het domein en zorg ervoor dat de tweede demotoepassing met de aangepaste titel wordt weergegeven.

Resources opschonen

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

De voorbeeldnaamruimte en alle resources verwijderen

Als u de voorbeeldnaamruimte verwijdert, worden ook alle resources in de naamruimte verwijderd.

  • Verwijder de volledige voorbeeldnaamruimte met behulp van de kubectl delete opdracht en geef de naamruimtenaam op.

    kubectl delete namespace ingress-basic

Resources afzonderlijk verwijderen

U kunt de resource ook afzonderlijk verwijderen.

  1. Verwijder de resources van de clusteruitgever.

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

  2. Geef de Helm-releases weer met de helm list opdracht. Zoek naar grafieken met de naam nginx en cert-manager, 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

  3. Verwijder de releases met behulp van de helm uninstall opdracht. In het volgende voorbeeld worden de NGINX-implementaties voor inkomend verkeer en certificaatbeheer verwijderd.

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

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

  4. Verwijder de twee voorbeeldtoepassingen.

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

  5. Verwijder de route voor inkomend verkeer dat verkeer naar de voorbeeld-apps heeft geleid.

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

  6. Verwijder de naamruimte zelf. Gebruik de opdracht en geef de kubectl delete 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: