Använda TLS med en ingresskontrollant i Azure Kubernetes Service (AKS)

Artikel
03/14/2024

TLS-protokollet (Transport Layer Security) använder certifikat för att ge säkerhet för kommunikation, kryptering, autentisering och integritet. Genom att använda TLS med en ingresskontrollant på AKS kan du skydda kommunikationen mellan dina program och uppleva fördelarna med en ingresskontrollant.

Du kan ta med egna certifikat och integrera dem med CSI-drivrutinen för Secrets Store. Du kan också använda cert-manager, som automatiskt genererar och konfigurerar Let's Encrypt-certifikat . Två program körs i AKS-klustret, som var och en är tillgänglig via en enda IP-adress.

Viktigt!

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

Viktigt!

Microsoft hanterar eller stöder inte cert-manager och eventuella problem som beror på dess användning. Information om problem med cert-manager finns i felsökningsdokumentationen för cert-manager.

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 använder kubernetes community-ingresskontrollanten.

Innan du börjar

Den här artikeln förutsätter att du har en ingresskontrollant och program konfigurerade. Om du behöver en ingresskontrollant eller exempelprogram kan du läsa Skapa en ingresskontrollant.
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-lagringsplatserna ingress-nginx och jetstack . Stegen som beskrivs i den här artikeln kanske inte är kompatibla med tidigare versioner av Helm-diagrammet, NGINX-ingresskontrollanten eller Kubernetes.
- Mer information om hur du konfigurerar och använder Helm finns i Installera program med Helm i AKS. Anvisningar för uppgradering finns i Helm-installationsdokumenten.
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 ACR från AKS.
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.
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).

Använda TLS med egna certifikat med CSI-drivrutinen för Secrets Store

Om du vill använda TLS med egna certifikat med CSI-drivrutinen för Secrets Store behöver du ett AKS-kluster med CSI-drivrutinen Secrets Store konfigurerad och en Azure Key Vault-instans.

Mer information finns i Konfigurera CSI-drivrutin för Secrets Store för att aktivera NGINX-ingresskontrollant med TLS.

Använda TLS med Let's Encrypt-certifikat

Om du vill använda TLS med Let's Encrypt-certifikat distribuerar du cert-manager, som automatiskt genererar och konfigurerar Let's Encrypt-certifikat.

Importera cert-manager-avbildningarna som används av Helm-diagrammet till din ACR

Azure CLI
Azure PowerShell

Använd az acr import för att importera följande bilder till din ACR.

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

Använd Import-AzContainerRegistryImage för att importera följande bilder till din ACR.

Kommentar

När du utför stegen för att importera avbildningarna till din ACR när du arbetar i Azure Government måste du inkludera parametern targetTag med värdet som representerar taggen för den avbildning som du vill importera.

$RegistryName = "<REGISTRY_NAME>"
$ResourceGroup = (Get-AzContainerRegistry | Where-Object {$_.name -eq $RegistryName} ).ResourceGroupName
$CertManagerRegistry = "quay.io"
$CertManagerTag = "v1.8.0"
$CertManagerImageController = "jetstack/cert-manager-controller"
$CertManagerImageWebhook = "jetstack/cert-manager-webhook"
$CertManagerImageCaInjector = "jetstack/cert-manager-cainjector"

Import-AzContainerRegistryImage -ResourceGroupName $ResourceGroup -RegistryName $RegistryName -SourceRegistryUri $CertManagerRegistry -SourceImage "${CertManagerImageController}:${CertManagerTag}"
Import-AzContainerRegistryImage -ResourceGroupName $ResourceGroup -RegistryName $RegistryName -SourceRegistryUri $CertManagerRegistry -SourceImage "${CertManagerImageWebhook}:${CertManagerTag}"
Import-AzContainerRegistryImage -ResourceGroupName $ResourceGroup -RegistryName $RegistryName -SourceRegistryUri $CertManagerRegistry -SourceImage "${CertManagerImageCaInjector}:${CertManagerTag}"

Kommentar

Du kan också importera Helm-diagram till din ACR. Mer information finns i Skicka och hämta Helm-diagram till en ACR.

Konfigurationsalternativ för ingresskontrollant

Du kan konfigurera din NGINX-ingresskontrollant med antingen en statisk offentlig IP-adress eller en dynamisk offentlig IP-adress. Om du använder en anpassad domän måste du lägga till en A-post i DNS-zonen. Om du inte använder en anpassad domän kan du konfigurera ett fullständigt domännamn (FQDN) för ingresskontrollantens IP-adress.

Skapa en statisk eller dynamisk offentlig IP-adress

Använda en statisk offentlig IP-adress

Du kan konfigurera ingresskontrollanten med en statisk offentlig IP-adress. Den statiska offentliga IP-adressen finns kvar om du tar bort ingresskontrollanten. IP-adressen finns inte kvar om du tar bort AKS-klustret.

När du uppgraderar ingresskontrollanten måste du skicka en parameter till Helm-versionen för att säkerställa att ingresskontrollanttjänsten blir medveten om lastbalanseraren som ska allokeras till den. För att HTTPS-certifikaten ska fungera korrekt använder du en DNS-etikett för att konfigurera ett FQDN för ingresskontrollantens IP-adress.

Azure CLI
Azure PowerShell

Hämta resursgruppens namn på AKS-klustret med az aks show kommandot .

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

Skapa en offentlig IP-adress med den statiska allokeringsmetoden med kommandot az network public-ip create . I följande exempel skapas en offentlig IP-adress med namnet myAKSPublicIP i aks-klusterresursgruppen som hämtades i föregående steg.
```
az network public-ip create --resource-group MC_myResourceGroup_myAKSCluster_eastus --name myAKSPublicIP --sku Standard --allocation-method static --query publicIp.ipAddress -o tsv
```

Kommentar

Du kan också skapa en IP-adress i en annan resursgrupp, som du kan hantera separat från ditt AKS-kluster. Om du skapar en IP-adress i en annan resursgrupp kontrollerar du att följande är sant:

Klusteridentiteten som används av AKS-klustret har delegerade behörigheter till resursgruppen, till exempel Nätverksdeltagare.
Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-resource-group"="<RESOURCE_GROUP>" . Ersätt <RESOURCE_GROUP> med namnet på resursgruppen där IP-adressen finns.

Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"="<DNS_LABEL>" . DNS-etiketten kan anges antingen när ingresskontrollanten först distribueras eller så kan den konfigureras senare.

Lägg till parametern --set controller.service.loadBalancerIP="<STATIC_IP>" . Ange din egen offentliga IP-adress som skapades i föregående steg.

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

Hämta resursgruppens namn på AKS-klustret med Get-AzAksCluster kommandot .

(Get-AzAksCluster -ResourceGroupName $ResourceGroup -Name myAKSCluster).NodeResourceGroup

Skapa en offentlig IP-adress med den statiska allokeringsmetoden med kommandot New-AzPublicIpAddress . I följande exempel skapas en offentlig IP-adress med namnet myAKSPublicIP i aks-klusterresursgruppen som hämtades i föregående steg.
```
(New-AzPublicIpAddress -ResourceGroupName MC_myResourceGroup_myAKSCluster_eastus -Name myAKSPublicIP -Sku Standard -AllocationMethod Static -Location eastus).IpAddress
```

Kommentar

Du kan också skapa en IP-adress i en annan resursgrupp, som du kan hantera separat från ditt AKS-kluster. Om du skapar en IP-adress i en annan resursgrupp kontrollerar du att följande är sant:

Klusteridentiteten som används av AKS-klustret har delegerade behörigheter till resursgruppen, till exempel Nätverksdeltagare.
Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-resource-group"="<RESOURCE_GROUP>" . Ersätt <RESOURCE_GROUP> med namnet på resursgruppen där IP-adressen finns.

Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"="<DNS_LABEL>" . DNS-etiketten kan anges antingen när ingresskontrollanten först distribueras eller så kan den konfigureras senare.

Lägg till parametern --set controller.service.loadBalancerIP="<STATIC_IP>" . Ange din egen offentliga IP-adress som skapades i föregående steg.

$DnsLabel = "<DNS_LABEL>"
$Namespace = "ingress-basic"
$StaticIP = "<STATIC_IP>"

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.loadBalancerIP=$StaticIP `
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Mer information finns i Använda en statisk offentlig IP-adress och DNS-etikett med AKS-lastbalanseraren.

Använda en dynamisk offentlig IP-adress

En offentlig IP-adress i Azure skapas för ingresskontrollanten när den skapas. Den offentliga IP-adressen är statisk för ingresskontrollantens livslängd. Den offentliga IP-adressen finns inte kvar om du tar bort ingresskontrollanten. Om du skapar en ny ingresskontrollant tilldelas den en ny offentlig IP-adress. Dina utdata bör se ut ungefär som följande exempelutdata.

kubectl get service Använd kommandot för att hämta den offentliga IP-adressen för ingresskontrollanten.

# 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

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

Om du använder en anpassad domän måste du lägga till en A-post i DNS-zonen. Om du inte använder en anpassad domän kan du konfigurera den offentliga IP-adressen med ett FQDN.

Azure CLI
Azure PowerShell

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

Lägg till en A-post i DNS-zonen med den externa IP-adressen för NGINX-tjänsten med .New-AzDnsRecordSet

$Records = @()
$Records += New-AzDnsRecordConfig -IPv4Address <External IP>
New-AzDnsRecordSet -Name "*" `
    -RecordType A `
    -ResourceGroupName <Name of Resource Group for the DNS Zone> `
    -ZoneName <Custom Domain Name> `
    -TTL 3600 `
    -DnsRecords $Records

Konfigurera ett FQDN för ingresskontrollanten

Du kan också konfigurera ett FQDN för ingresskontrollantens IP-adress i stället för en anpassad domän genom att ange en DNS-etikett. Ditt FQDN bör följa det här formuläret: <CUSTOM DNS LABEL>.<AZURE REGION NAME>.cloudapp.azure.com.

Viktigt!

DNS-etiketten måste vara unik på dess Azure-plats.

Du kan konfigurera ditt fullständiga domännamn med någon av följande metoder:

Ange DNS-etiketten med Hjälp av Azure CLI eller Azure PowerShell.
Ange DNS-etiketten med hjälp av Helm-diagraminställningar.

Mer information finns i Dns-namnetiketter för offentlig IP-adress.

Ange DNS-etiketten med Hjälp av Azure CLI eller Azure PowerShell

Ersätt <DNS_LABEL> med din unika DNS-etikett.

Azure CLI
Azure PowerShell

# 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

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

# Get the public IP address for the ingress controller
$PublicIp = Get-AzPublicIpAddress | Where-Object {$_.IpAddress -eq $AksIpAddress}

# Update public IP address with DNS name
$PublicIp.DnsSettings = @{"DomainNameLabel" = "<DNS_LABEL>"}
$UpdatedPublicIp = Set-AzPublicIpAddress -PublicIpAddress $publicIp

# Display the FQDN
Write-Output $UpdatedPublicIp.DnsSettings.Fqdn

Ange DNS-etiketten med hjälp av Helm-diagraminställningar

Du kan skicka en anteckningsinställning till helm-diagramkonfigurationen med hjälp av parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" . Den här parametern kan anges när ingresskontrollanten 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. Ersätt <DNS_LABEL> med din unika DNS-etikett.

Azure CLI
Azure PowerShell

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

$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

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 använder cert-manager, som tillhandahåller automatisk Lets Encrypt-certifikatgenerering och hanteringsfunktioner.

Om du vill installera cert-manager-kontrollanten använder du följande kommandon.

Azure CLI
Azure PowerShell

# 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

# Set variable for ACR location to use for pulling images
$AcrUrl = (Get-AzContainerRegistry -ResourceGroupName $ResourceGroup -Name $RegistryName).LoginServer

# 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 $CertManagerTag `
  --set installCRDs=true `
  --set nodeSelector."kubernetes\.io/os"=linux `
  --set image.repository="${AcrUrl}/${CertManagerImageController}" `
  --set image.tag=$CertManagerTag `
  --set webhook.image.repository="${AcrUrl}/${CertManagerImageWebhook}" `
  --set webhook.image.tag=$CertManagerTag `
  --set cainjector.image.repository="${AcrUrl}/${CertManagerImageCaInjector}" `
  --set cainjector.image.tag=$CertManagerTag

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

Skapa en utfärdare av CA-kluster

Innan certifikat kan utfärdas kräver cert-manager någon av följande utfärdare:

En utfärdare, som fungerar i ett enda namnområde.
En ClusterIssuer-resurs som fungerar i alla namnområden.

Mer information finns i dokumentationen för utfärdare av certifikatutfärdare .

Skapa en kluster utfärdare, till exempel cluster-issuer.yaml, med hjälp av följande exempelmanifest. Ersätt MY_EMAIL_ADDRESS 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 utfärdaren med kommandot kubectl apply .

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

Uppdatera dina ingressvägar

Du måste uppdatera dina inkommande vägar för att hantera trafik till ditt fullständiga domännamn eller din anpassade domän.

I följande exempel dirigeras trafik som sådan:

Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN dirigeras till tjänsten aks-helloworld-one .
Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN/hello-world-two dirigeras till tjänsten aks-helloworld-two .
Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN/statisk dirigeras till tjänsten med namnet aks-helloworld-one för statiska tillgångar.

Kommentar

Om du har konfigurerat ett FQDN för ingresskontrollantens 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 fullständiga domännamn till exempel är 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 eller uppdatera hello-world-ingress.yaml filen med hjälp av följande YAML-exempelfil. spec.tls.hosts Uppdatera och spec.rules.host till det DNS-namn som du skapade i ett tidigare steg.

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

Uppdatera ingressresursen kubectl apply med 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 önskat X.509-certifikat. Mer information finns i certifikat för cert-manager.

Cert-manager skapar automatiskt ett certifikatobjekt åt dig med 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 kubectl get certificate --namespace ingress-basic kommandot och kontrollera att READY är Sant. Det kan ta flera minuter att hämta utdata.

kubectl get certificate --namespace ingress-basic

Följande utdata visar certifikatets status.

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

Testa ingresskonfigurationen

Öppna en webbläsare för att hello-world-ingress. MY_CUSTOM_DOMAIN eller FQDN för din Kubernetes-ingresskontrollant. Kontrollera att följande är sant:

Du omdirigeras för att använda HTTPS.
Certifikatet är betrott.
Demoprogrammet visas i webbläsaren.
Lägg till /hello-world-two i slutet av domänen och se 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 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 tar bort exempelnamnområdet tas även alla resurser i namnområdet bort.

Ta bort hela exempelnamnområdet med kommandot kubectl delete och ange namnområdesnamnet.
```
kubectl delete namespace ingress-basic
```

Ta bort resurser individuellt

Du kan också ta bort resursen individuellt.

Ta bort klusterproblemastreringsresurserna.

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

Visa en lista över Helm-versionerna helm list med 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 kommandot helm uninstall . 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 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 inkommande vägen som dirigerade trafik till exempelapparna.
```
kubectl delete -f hello-world-ingress.yaml --namespace ingress-basic
```
Ta bort själva namnområdet. kubectl delete Använd kommandot och ange namnområdets namn.
```
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:

Aktivera tillägget HTTP-programroutning

Använda TLS med en ingresskontrollant i Azure Kubernetes Service (AKS)

Innan du börjar

Använda TLS med egna certifikat med CSI-drivrutinen för Secrets Store

Använda TLS med Let's Encrypt-certifikat

Importera cert-manager-avbildningarna som används av Helm-diagrammet till din ACR

Konfigurationsalternativ för ingresskontrollant

Skapa en statisk eller dynamisk offentlig IP-adress

Använda en statisk offentlig IP-adress

Använda en dynamisk offentlig IP-adress

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

Konfigurera ett FQDN för ingresskontrollanten

Ange DNS-etiketten med Hjälp av Azure CLI eller Azure PowerShell

Ange DNS-etiketten med hjälp av Helm-diagraminställningar

Installera cert-manager

Skapa en utfärdare av CA-kluster

Uppdatera dina ingressvägar

Kontrollera att ett certifikatobjekt har skapats

Testa ingresskonfigurationen

Rensa resurser

Ta bort exempelnamnområdet och alla resurser

Ta bort resurser individuellt

Nästa steg

Ytterligare resurser