Konfigurowanie usługi Azure DNS i protokołu TLS za pomocą implementacji interfejsu API bramy routingu aplikacji

Dzięki interfejsowi Application Routing Gateway API użytkownicy mogą łatwo udostępniać aplikacje HTTPS w usłudze AKS za pomocą własnych certyfikatów z usługi Azure Key Vault, w tym z automatycznym publikowaniem nazwy domeny. Operator Application Routing integruje się z usługami Azure DNS i Azure Key Vault oraz synchronizuje zasób SecretProviderClass, obiekt Secret platformy Kubernetes dla certyfikatów TLS, pole odbiornika certificateRefs oraz oddzielne wdrożenie external-dns, dzięki czemu nie trzeba ręcznie zarządzać tymi zasobami.

W tym artykule pokazano, jak wykonać następujące działania:

  • Utwórz wymagane zasoby wstępne platformy Azure (strefę DNS platformy Azure, Azure Key Vault, tożsamość zarządzaną przypisaną przez użytkownika, przypisania ról i federacyjne poświadczenia tożsamości).
  • Skonfiguruj odbiornik, Gateway aby zakończyć protokół TLS przy użyciu certyfikatu przechowywanego w Azure Key Vault za pośrednictwem opcji protokołu TLS i odbiornika kubernetes.azure.com/tls-cert-keyvault-urikubernetes.azure.com/tls-cert-service-account.
  • Użyj zasobów niestandardowych ClusterExternalDNS i ExternalDNS, aby opublikować rekordy DNS w usłudze Azure DNS na podstawie nazw hostów zasobów Gateway, HTTPRoute i GRPCRoute.

Jak działa integracja

Operator Application Routing udostępnia dwie integracje automatyzujące zasoby, które w przeciwnym razie trzeba byłoby utworzyć ręcznie, aby udostępnić zasób Gateway online przy użyciu domeny niestandardowej i terminacji TLS.

Integracja protokołu TLS

Gateway Gdy zasób korzysta z klasy GatewayClass zarządzanej ( approuting-istio z implementacji interfejsu API usługi Application Routing Gateway) lub istio (z dodatku usługi Istio Service Mesh) — a odbiornik ma następujące dwie opcje protokołu TLS, operator routingu aplikacji uzgadnia zasoby potrzebne do zakończenia protokołu TLS przy użyciu certyfikatu przechowywanego w Azure Key Vault:

Klucz opcji PROTOKOŁU TLS Value
kubernetes.azure.com/tls-cert-keyvault-uri Identyfikator URI certyfikatu Azure Key Vault, z którego ma zostać pobrany certyfikat TLS. Użyj adresu URI bez wersji (na przykład https://<vault>.vault.azure.net/certificates/<cert>), aby operator automatycznie uwzględniał rotacje certyfikatów w usłudze Azure Key Vault.
kubernetes.azure.com/tls-cert-service-account Nazwa konta usługi ServiceAccount Kubernetes w tej samej przestrzeni nazw co Gateway. Element ServiceAccount musi być powiązany z tożsamością zarządzaną przypisaną przez użytkownika za pośrednictwem Microsoft Entra Workload Identity, a ta tożsamość zarządzana musi mieć rolę Key Vault Secrets User w docelowym magazynie Azure Key Vault.

Dla każdego odbiornika, który obsługuje obie opcje protokołu TLS, operator:

  1. Tworzy zasób SecretProviderClass o nazwie kv-gw-cert-<gateway-name>-<listener-name> w przestrzeni nazw Gateway, skonfigurowany tak, aby pobierać certyfikat z usługi Azure Key Vault przy użyciu uwierzytelniania tożsamością obciążenia.
  2. Wyzwala dostawcę Azure Key Vault dla sterownika CSI Secrets Store, aby zsynchronizować certyfikat do postaci obiektu Secret platformy Kubernetes o tej samej nazwie w przestrzeni nazw obiektu kubernetes.io/tls, jako Gateway.
  3. Aktualizuje pole listenera tls.certificateRefs, tak aby odwoływało się do zsynchronizowanego sekretu Kubernetes.

Integracja usługi DNS

Operator routingu aplikacji zarządza wystąpieniem external-dns za pośrednictwem dwóch zasobów niestandardowych:

Zasób niestandardowy Scope
ClusterExternalDNS (clusterexternaldnses.approuting.kubernetes.azure.com) Zakres klastra. Obserwuje zasoby Gateway, HTTPRoute i GRPCRoute we wszystkich przestrzeniach nazw klastra.
ExternalDNS (externaldnses.approuting.kubernetes.azure.com) Zakres przestrzeni nazw. Obserwuje tylko zasoby Gateway, HTTPRoute i GRPCRoute w tej samej przestrzeni nazw co zasób niestandardowy.

Oba zasoby niestandardowe obsługują opcjonalne selektory filters, aby jeszcze bardziej zawęzić zakres zasobów obserwowanych przez zarządzaną instancję external-dns w swoim zakresie działania:

Filter Co to zawęża
filters.gatewayLabels Ogranicza zasoby Gateway obserwowane przez kontroler.
filters.routeAndIngressLabels Ogranicza, które HTTPRoute i Ingress zasoby obserwuje kontroler.

Dla każdego zasobu niestandardowego operator routingu aplikacji:

  1. Wdraża zarządzane wystąpienie external-dns, skonfigurowane do pobierania rekordów z zasobów HTTPRoute i GRPCRoute, i kieruje je do określonych stref Azure DNS.
  2. Uwierzytelnia w usłudze Azure DNS przy użyciu tożsamości obciążenia roboczego Microsoft Entra za pośrednictwem konta usługi wskazanego w polu identity zasobu niestandardowego.
  3. Publikuje rekordy A w każdej z wymienionych stref Azure DNS dla każdej nazwy hosta HTTPRoute lub GRPCRoute, która jest powiązana z zarządzanym zasobem Gateway objętym zakresem.

Prerequisites

  • Klaster AKS z włączonymi obiema następującymi funkcjami:

    • Dodatek routingu aplikacji (--enable-app-routing). Ten dodatek wdraża operatora routingu aplikacji w klastrze, który jest składnikiem, który uzgadnia integracje DNS i TLS opisane w tym artykule. W istniejącym klastrze można również włączyć tę funkcję przy użyciu polecenia az aks approuting enable.
    • Zarządzana implementacja interfejsu Gateway API, z którą operator może się integrować. Wybierz jedną z następujących opcji (obie opcje wzajemnie się wykluczają i nie można ich jednocześnie włączyć):

    Aby korzystać z tych integracji, włącz zarówno dodatek Application Routing (za pomocą polecenia az aks approuting enable), jak i jedną z wcześniej wymienionych zarządzanych implementacji interfejsu Gateway API.

  • Włączona w klastrze instalacja interfejsu API Managed Gateway.

  • Funkcja tożsamości obciążenia Microsoft Entra włączona w klastrze wraz z wystawcą OIDC. Obie funkcje można włączyć za pomocą flag --enable-oidc-issuer i --enable-workload-identity w az aks create lub az aks update.

  • Dodatek dostawcy Azure Key Vault dla sterownika CSI magazynu sekretów włączony w klastrze. Można ją włączyć za pomocą polecenia az aks enable-addons z argumentem --addons azure-keyvault-secrets-provider lub przez przekazanie --enable-kv do az aks approuting enable lub az aks approuting update.

  • Wersja Azure CLI 2.86.0 lub wyższa. Uruchom polecenie az --version , aby znaleźć swoją azure-cli wersję i uruchomić az upgrade polecenie , aby uaktualnić.

  • Wystarczające uprawnienia kontroli dostępu opartej na rolach (RBAC) platformy Azure dla własnej tożsamości, aby tworzyć przypisania ról i poświadczenia federacyjne tożsamości. Rola Owner lub kombinacja Role Based Access Control Administrator i Managed Identity Contributor jest wystarczająca.

Note

Flagi --attach-kv i --attach-zones w poleceniu az aks approuting update (oraz podpolecenia az aks approuting zone) są przeznaczone dla starszego środowiska opartego na rozwiązaniu NGINX, w którym własna tożsamość zarządzana przypisana przez użytkownika dodatku Application Routing ma przyznany, oparty na mechanizmie Azure RBAC, dostęp do jednego magazynu Azure Key Vault i jednej strefy DNS. Nie są używane przez integrację Gateway API opisaną w tym artykule. Nowa funkcja korzysta z tożsamości obciążenia Microsoft Entra zamiast z tożsamości zarządzanej dodatku, dlatego musisz utworzyć własną tożsamość zarządzaną przypisaną przez użytkownika, przypisać jej odpowiednie role usługi Azure DNS i Azure Key Vault oraz utworzyć poświadczenia federacyjne, które powiążą ją z obiektami ServiceAccount platformy Kubernetes, do których odwołujesz się w opcjach TLS odbiornika Gateway oraz w zasobach niestandardowych ExternalDNS/ClusterExternalDNS.

Ustaw następujące zmienne środowiskowe. Instrukcja wykorzystuje je ponownie w każdym następnym poleceniu:

export RESOURCE_GROUP=<resource-group-name>
export CLUSTER=<cluster-name>
export LOCATION=<azure-region>

Pobierz poświadczenia klastra kubectl:

az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER

Tworzenie infrastruktury Azure

Tworzenie strefy Azure DNS

Jeśli masz już strefę Azure DNS, w której operator routingu aplikacji ma zarządzać rekordami, możesz pominąć ten krok i przypisać wartość ZONE_NAME do istniejącej nazwy strefy.

export ZONE_NAME=<dns-zone-name>
az network dns zone create --resource-group $RESOURCE_GROUP --name $ZONE_NAME
export ZONE_ID=$(az network dns zone show --resource-group $RESOURCE_GROUP --name $ZONE_NAME --query id -o tsv)

Tworzenie Azure Key Vault i certyfikatu

Utwórz Azure Key Vault przechowujący certyfikat TLS. Skonfiguruj magazyn tak, aby używał kontroli dostępu opartej na rolach platformy Azure (Azure RBAC) do autoryzacji, co jest zalecanym modelem uprawnień:

export KV_NAME=<key-vault-name>
az keyvault create \
  --name $KV_NAME \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --enable-rbac-authorization true

Note

Aby utworzyć certyfikat w następnym kroku, Twoja tożsamość w usłudze Azure musi mieć rolę Key Vault Certificates Officer (lub Key Vault Administrator) w magazynie. Przed kontynuowaniem przypisz tę rolę do sejfu.

Utwórz certyfikat wieloznaczny z podpisem własnym w usłudze Azure Key Vault. W przypadku wdrożeń produkcyjnych zamiast tego zaimportuj certyfikat podpisany przez urząd certyfikacji (CA), używając polecenia az keyvault certificate import.

cat > cert-policy.json <<EOF
{
  "issuerParameters": { "name": "Self" },
  "keyProperties": { "exportable": true, "keyType": "RSA", "keySize": 2048, "reuseKey": false },
  "secretProperties": { "contentType": "application/x-pkcs12" },
  "x509CertificateProperties": {
    "subject": "CN=*.${ZONE_NAME}",
    "subjectAlternativeNames": { "dnsNames": ["*.${ZONE_NAME}", "${ZONE_NAME}"] },
    "validityInMonths": 12,
    "keyUsage": ["digitalSignature", "keyEncipherment"]
  }
}
EOF

az keyvault certificate create \
  --vault-name $KV_NAME \
  --name approuting-demo-cert \
  --policy @cert-policy.json

Przechwyć niewersyfikowany identyfikator URI certyfikatu. Operator routingu aplikacji używa tego adresu URI do skonfigurowania elementu SecretProviderClass. Niewersyjowany identyfikator URI zapewnia, że operator pobiera nowe wersje certyfikatów w Azure Key Vault podczas rotacji certyfikatu.

export CERT_URI=$(az keyvault certificate show \
  --vault-name $KV_NAME \
  --name approuting-demo-cert \
  --query id -o tsv | sed 's|/[^/]*$||')
echo "Cert URI: $CERT_URI"

Utwórz tożsamość zarządzaną przypisaną przez użytkownika i przypisz role RBAC platformy Azure

Utwórz tożsamość zarządzaną przypisaną przez użytkownika, której wdrożenie operatora routingu aplikacji external-dns oraz synchronizacja TLS odbiornika bramy używają do uwierzytelniania w usługach Azure DNS i Azure Key Vault.

export UAMI_NAME=<managed-identity-name>
az identity create --resource-group $RESOURCE_GROUP --name $UAMI_NAME --location $LOCATION
export UAMI_CLIENT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $UAMI_NAME --query clientId -o tsv)
export UAMI_PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $UAMI_NAME --query principalId -o tsv)

Przypisz tożsamości zarządzanej rolę DNS Zone Contributor w docelowej strefie Azure DNS oraz rolę Key Vault Secrets User w docelowym magazynie Azure Key Vault:

az role assignment create \
  --assignee-object-id $UAMI_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal \
  --role "DNS Zone Contributor" \
  --scope $ZONE_ID

az role assignment create \
  --assignee-object-id $UAMI_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal \
  --role "Key Vault Secrets User" \
  --scope $(az keyvault show --name $KV_NAME --query id -o tsv)

Tworzenie przestrzeni nazw, konta usługi i poświadczeń tożsamości federacyjnej

Integracje TLS i DNS operatora Application Routing obie uwierzytelniają się na platformie Azure za pośrednictwem konta usługi Kubernetes powiązanego z zarządzaną tożsamością przypisaną przez użytkownika za pomocą poświadczenia federacyjnej tożsamości (FIC). Każda (namespace, ServiceAccount) para, która musi się uwierzytelnić, wymaga jednego FIC.

Skopiuj adres URL wystawcy OIDC klastra:

export OIDC_ISSUER=$(az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER --query oidcIssuerProfile.issuerUrl -o tsv)

Dla każdej przestrzeni nazw, w której planujesz wdrożyć zasób Gateway, który korzysta z integracji TLS, lub zasób ExternalDNS, utwórz przestrzeń nazw, poświadczenie tożsamości federacyjnej dla obiektu ServiceAccount oraz sam obiekt ServiceAccount. Poniższy przykład tworzy dwie przestrzenie nazw, app-a i app-b, z których każda zawiera konto usługi o nazwie approuting-demo-sa:

export SA_NAME=approuting-demo-sa
for ns in app-a app-b; do
  kubectl create namespace $ns

  az identity federated-credential create \
    --identity-name $UAMI_NAME \
    --resource-group $RESOURCE_GROUP \
    --name approuting-demo-fic-$ns \
    --issuer $OIDC_ISSUER \
    --subject "system:serviceaccount:$ns:$SA_NAME" \
    --audiences "api://AzureADTokenExchange"

  kubectl apply -n $ns -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: $SA_NAME
  annotations:
    azure.workload.identity/client-id: $UAMI_CLIENT_ID
  labels:
    azure.workload.identity/use: "true"
EOF
done

Adnotacja azure.workload.identity/client-id wiąże obiekt ServiceAccount z tożsamością zarządzaną, a etykieta azure.workload.identity/use: "true" instruuje webhook Microsoft Entra Workload Identity, aby wstrzyknął token federacyjny do podów korzystających z obiektu ServiceAccount. Oba są wymagane, aby integracje TLS i DNS operatora Application Routing mogły pomyślnie uwierzytelnić się w usłudze Azure.

Skonfiguruj terminację TLS na bramie

Wdróż przykładowe httpbin obciążenie robocze w każdej przestrzeni nazw:

for ns in app-a app-b; do
  kubectl apply -n $ns -f https://raw.githubusercontent.com/istio/istio/release-1.27/samples/httpbin/httpbin.yaml
done

Gateway Utwórz zasób w każdej przestrzeni nazw z odbiornikiem HTTPS odwołującym się do certyfikatu Azure Key Vault za pomocą opcji protokołu TLS. Każdy z nich Gateway używa własnego podrzędnego hosta strefy Azure DNS (na przykład a.<zone> i b.<zone>):

Note

W przykładach w tym artykule użyto klasy gatewayClassName: approuting-istioGatewayClass dostarczonej przez implementację interfejsu API usługi Application Routing Gateway. Jeśli zamiast tego włączysz dodatek siatki usług Istio, ustaw gatewayClassName: istio w swoich zasobach Gateway. Integracje DNS i TLS zachowują się identycznie dla obu zarządzanych klas GatewayClasses.

for pair in "app-a:a" "app-b:b"; do
  ns=${pair%%:*}
  sub=${pair##*:}
  fqdn=${sub}.${ZONE_NAME}
  kubectl apply -n $ns -f - <<EOF
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: ${sub}-gateway
  labels:
    app: approuting-demo
    zone: ${sub}
spec:
  gatewayClassName: approuting-istio
  listeners:
  - name: https
    hostname: $fqdn
    port: 443
    protocol: HTTPS
    tls:
      mode: Terminate
      options:
        kubernetes.azure.com/tls-cert-keyvault-uri: $CERT_URI
        kubernetes.azure.com/tls-cert-service-account: $SA_NAME
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: ${sub}-route
spec:
  parentRefs:
  - name: ${sub}-gateway
  hostnames: ["$fqdn"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
EOF
done

Poczekaj, aż każdy Gateway osiągnie stan Programmed:

kubectl wait -n app-a --for=condition=programmed gateway a-gateway --timeout=300s
kubectl wait -n app-b --for=condition=programmed gateway b-gateway --timeout=300s

Sprawdź, czy operator Application Routing utworzył obiekt SecretProviderClass oraz czy dostawca Azure Key Vault dla Secrets Store CSI Driver zsynchronizował certyfikat do obiektu Secret kubernetes.io/tls w każdej przestrzeni nazw:

kubectl get secretproviderclass,secret -n app-a
kubectl get secretproviderclass,secret -n app-b

Przykładowe dane wyjściowe dla jednej przestrzeni nazw:

NAME                                                                        AGE
secretproviderclass.secrets-store.csi.x-k8s.io/kv-gw-cert-a-gateway-https   2m

NAME                                TYPE                DATA   AGE
secret/kv-gw-cert-a-gateway-https   kubernetes.io/tls   2      2m

Skonfiguruj rekordy DNS platformy Azure przy użyciu ClusterExternalDNS

Wdróż wystąpienie o zakresie klastra external-dns, które publikuje rekordy A dla zasobów Gateway w dowolnej przestrzeni nazw przez zastosowanie niestandardowego zasobu ClusterExternalDNS.

kubectl apply -f - <<EOF
apiVersion: approuting.kubernetes.azure.com/v1alpha1
kind: ClusterExternalDNS
metadata:
  name: demo-cluster-dns
spec:
  resourceName: demo-cluster-dns
  resourceNamespace: app-a
  dnsZoneResourceIDs:
  - $ZONE_ID
  resourceTypes:
  - gateway
  identity:
    type: workloadIdentity
    serviceAccount: $SA_NAME
EOF

Pole resourceNamespace określa przestrzeń nazw, w której operator routingu aplikacji wdraża wystąpienie zarządzane external-dns . Element ServiceAccount, identity.serviceAccount do którego się odwołuje, musi istnieć w tej przestrzeni nazw.

Po około minucie w strefie Azure DNS są wyświetlane dwa rekordy A — jeden dla każdego z nichGateway:

az network dns record-set a list --resource-group $RESOURCE_GROUP --zone-name $ZONE_NAME -o table
Name    ResourceGroup              Ttl    Type    AutoRegistered    Metadata
------  -------------------------  -----  ------  ----------------  --------
a       <your-rg>                  300    A       False
b       <your-rg>                  300    A       False

Konfigurowanie rekordów Azure DNS przy użyciu ExternalDNS ograniczonego do przestrzeni nazw

Aby opublikować rekordy tylko dla podzbioru zasobów Gateway, użyj zasobu niestandardowego ExternalDNS ograniczonego do przestrzeni nazw. W przeciwieństwie do ClusterExternalDNS, wariant ograniczony do przestrzeni nazw obserwuje tylko zasoby Gateway, HTTPRoute i GRPCRoute w tej samej przestrzeni nazw co zasób niestandardowy. Podobnie jak w przypadku ClusterExternalDNS, możesz opcjonalnie jeszcze bardziej zawęzić zakres za pomocą selektorów filters.gatewayLabels i filters.routeAndIngressLabels.

Najpierw usuń element ClusterExternalDNS z poprzedniego kroku:

kubectl delete clusterexternaldns demo-cluster-dns

Wdróż nowy Gateway w app-a z etykietą zone: c i odpowiadającym mu HTTPRoute:

kubectl apply -n app-a -f - <<EOF
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: c-gateway
  labels:
    app: approuting-demo
    zone: c
spec:
  gatewayClassName: approuting-istio
  listeners:
  - name: https
    hostname: c.${ZONE_NAME}
    port: 443
    protocol: HTTPS
    tls:
      mode: Terminate
      options:
        kubernetes.azure.com/tls-cert-keyvault-uri: $CERT_URI
        kubernetes.azure.com/tls-cert-service-account: $SA_NAME
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: c-route
spec:
  parentRefs:
  - name: c-gateway
  hostnames: ["c.${ZONE_NAME}"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
EOF

kubectl wait -n app-a --for=condition=programmed gateway c-gateway --timeout=300s

Zastosuj zasób ograniczony do przestrzeni nazw w ExternalDNS z filtrem etykiet dla app-a:

kubectl apply -n app-a -f - <<EOF
apiVersion: approuting.kubernetes.azure.com/v1alpha1
kind: ExternalDNS
metadata:
  name: demo-ns-dns
spec:
  resourceName: demo-ns-dns
  dnsZoneResourceIDs:
  - $ZONE_ID
  resourceTypes:
  - gateway
  identity:
    type: workloadIdentity
    serviceAccount: $SA_NAME
  filters:
    gatewayLabels: "zone=c"
EOF

Obowiązują dwie reguły określania zakresu:

  • Zakres ExternalDNS przestrzeni nazw wyklucza b-gateway , ponieważ znajduje się w app-b przestrzeni nazw.
  • Filtr etykiet zone=c wyklucza a-gateway, ponieważ znajduje się w app-a, ale ma etykietę zone=a.

Operator routingu aplikacji publikuje nowy rekord A dla elementu c.${ZONE_NAME}:

az network dns record-set a list --resource-group $RESOURCE_GROUP --zone-name $ZONE_NAME -o table

Weryfikowanie ruchu HTTPS zakończonego protokołem TLS

Rozwiąż nazwę hosta elementu Gateway przy użyciu autorytatywnego serwera nazw strefy Azure DNS i wyślij żądanie HTTPS:

NS=$(az network dns zone show --resource-group $RESOURCE_GROUP --name $ZONE_NAME --query 'nameServers[0]' -o tsv | sed 's/\.$//')
GATEWAY_IP=$(dig +short @${NS} a.${ZONE_NAME} | tail -1)
curl -k -I --resolve "a.${ZONE_NAME}:443:${GATEWAY_IP}" "https://a.${ZONE_NAME}/get"

Odpowiedź HTTP/2 200 powinna być widoczna. Certyfikat TLS, który przedstawia brama, jest zsynchronizowany z Azure Key Vault. W przypadku zaimportowania certyfikatu podpisanego przez urząd certyfikacji zastąp element -k , --cacert <path-to-ca-chain> aby zweryfikować łańcuch certyfikatów.

Note

W tym przykładzie użyto curl --resolve, aby ominąć lokalne rozwiązywanie nazw DNS i skierować żądanie do zewnętrznego adresu IP bramy. Ta metoda jest przydatna do testowania przed delegowaniem strefy DNS do rejestratora. W środowisku produkcyjnym skonfiguruj rejestratora domeny tak, aby delegował strefę do serwerów nazw Azure DNS zwróconych przez az network dns zone show --query 'nameServers'.

Ograniczenia

  • Integracje dns i TLS mają zastosowanie tylko do Gateway zasobów korzystających z zarządzanej klasy GatewayClass: approuting-istio ( implementacja interfejsu API routingu aplikacji) lub istio ( dodatek usługi Istio service mesh). Gateway zasoby korzystające z żadnej innej klasy GatewayClass nie są obsługiwane.
  • Zasób niestandardowy ClusterExternalDNS lub ExternalDNS może odwoływać się maksymalnie do siedmiu stref Azure DNS za pośrednictwem dnsZoneResourceIDs. Wszystkie strefy, do których odwołuje się pojedynczy zasób niestandardowy, muszą znajdować się w tej samej subskrypcji platformy Azure i tej samej grupie zasobów. Muszą również mieć taki sam typ (publiczny lub prywatny).
  • Wystąpienie zarządzane external-dns nie usuwa automatycznie rekordów DNS podczas usuwania zasobu niestandardowego ClusterExternalDNS lub ExternalDNS . Aby usunąć osierocone rekordy, usuń je bezpośrednio ze strefy Azure DNS po usunięciu zasobu niestandardowego.
  • Uzgadnianie rekordów DNS z TLSRoute zasobów nie jest obecnie obsługiwane. Zarządzana instancja external-dns pobiera rekordy wyłącznie z zasobów Gateway, HTTPRoute i GRPCRoute.

Następne kroki