Installazione di ExternalDNS per l'esplorazione dei servizi

Questo argomento spiega come distribuire ExternalDNS in un cluster del carico di lavoro in Tanzu Kubernetes Grid.

Il servizio ExternalDNS pubblica i record DNS per le applicazioni nei server DNS mediante un'interfaccia nativa Kubernetes dichiarativa. Viene incluso nel pacchetto come pacchetto gestito dalla CLI in Tanzu Kubernetes Grid.

Negli ambienti in cui Harbor è distribuito in un cluster di servizi condivisi con bilanciamento del carico (AWS, Azure e vSphere con NSX Advanced Load Balancer), è possibile utilizzare ExternalDNS per pubblicare un nome host DNS per il servizio Harbor. In questo modo, fornisce l'accesso a Harbor da altri cluster. Per ulteriori informazioni, vedere Registro Harbor ed ExternalDNS.

Prerequisiti

Una macchina bootstrap con le seguenti installazioni:
- CLI di Tanzu, plug-in della CLI di Tanzu e kubectl.
- yq v4.5 o versione successiva.
È stato distribuito un cluster di gestione su vSphere, Amazon Web Services (AWS) o Azure, in un ambiente connesso a Internet o con restrizioni su Internet. Se si utilizza Tanzu Kubernetes Grid in un ambiente con limitazioni Internet, prima di distribuire il cluster di gestione è stata eseguita la procedura indicata in Preparazione della distribuzione dei cluster di gestione in un ambiente con limitazioni Internet.
Si è connessi alla CLI di Tanzu con il comando di accesso tanzu context use.
Sono stati determinati i nomi di dominio completi (FQDN) per i servizi da esporre con ExternalDNS al server DNS.

Preparazione del cluster per la distribuzione di ExternalDNS

Il servizio ExternalDNS deve essere distribuito nello stesso cluster dei servizi per cui esporterà i record DNS.

Per installare Harbor, soddisfare i prerequisiti ed eseguire la procedura di Installazione di Harbor per il registro del servizio.
ExternalDNS supporta la creazione di record sia per le risorse Kubernetes Services sia per quelle Contour HTTPProxy. Se si desidera creare record per le risorse Contour HTTPProxy in un cluster di carichi di lavoro, è necessario installare il pacchetto Contour nel cluster. Per istruzioni, vedere Installazione di Contour per il controllo dell'ingresso. Il pacchetto Contour è richiesto anche da Harbor.

Preparazione del file di configurazione per il pacchetto ExternalDNS

Il pacchetto ExternalDNS è stato convalidato con AWS (Route 53), DNS Azure e RFC2136 (BIND). La configurazione specificata consente di esportare i record per le risorse Contour HTTPProxy e per i Services di Kubernetes di tipo LoadBalancer.

La community di DNS esterno mantiene le integrazioni con molti provider di DNS a livelli di stabilità variabili. Ad eccezione dei casi indicati, VMware non garantisce il supporto per l'integrazione del pacchetto ExternalDNS con provider specifici.

AWS (Route 53)

Per preparare il file di configurazione per la distribuzione del pacchetto ExternalDNS in AWS:

Creare una zona ospitata all'interno di Route 53 con il dominio che verrà utilizzato dai servizi.
Registrare l'ID della zona ospitata. Questo ID verrà utilizzato in un secondo momento durante la configurazione di ExternalDNS.
Creare un criterio IAM per ExternalDNS che consenta a ExternalDNS di aggiornare Route 53. Nella console AWS, andare nel dashboard IAM e in Gestione accesso (Access Management) andare alla schermata Criteri. Fare clic su Crea criterio e passare alla scheda JSON. Incollare il seguente criterio. Se necessario, è possibile ritoccare il criterio per consentire gli aggiornamenti della zona ospitata appena creata. Completare la procedura guidata.
```
{
 "Version": "2012-10-17",
 "Statement": [
   {
     "Effect": "Allow",
     "Action": [
       "route53:ChangeResourceRecordSets"
     ],
     "Resource": [
       "arn:aws:route53:::hostedzone/*"
     ]
   },
   {
     "Effect": "Allow",
     "Action": [
       "route53:ListHostedZones",
       "route53:ListResourceRecordSets"
     ],
     "Resource": [
       "*"
     ]
   }
 ]
}
```
Creare un utente IAM per ExternalDNS con il criterio creato in precedenza. Nella console AWS, andare nella schermata Utenti (Users) e fare clic su Aggiungi utenti (Add users). Specificare un nome per l'utente IAM e assicurarsi che Accesso programmatico (Programmatic access) sia attivato. Nella schermata Autorizzazioni (Permissions) della procedura guidata, fare clic su Collega direttamente i criteri esistenti (Attach existing policies directly), quindi selezionare il criterio creato nel passaggio precedente.
Continuare fino alla pagina finale della procedura guidata. Registrare l'ID della chiave di accesso e la chiave di accesso segreta. Per rendere queste credenziali di Route 53 disponibili per ExternalDNS, creare un segreto Kubernetes nello spazio dei nomi in cui ExternalDNS sarà in esecuzione.
1. Impostare il contesto di kubectl sul cluster in cui si distribuisce ExternalDNS. Ad esempio:
```
kubectl config use-context tkg-services-admin@tkg-services
```
2. Creare il segreto Kubernetes:
```
kubectl -n tanzu-system-service-discovery create secret generic route53-credentials \
--from-literal=aws_access_key_id=YOUR-ACCESS-KEY-ID \
--from-literal=aws_secret_access_key=YOUR-SECRET-ACCESS-KEY
```
  Dove YOUR-ACCESS-KEY-ID e YOUR-SECRET-ACCESS-KEY sono le credenziali registrate in precedenza.
Creare un file di configurazione per il pacchetto ExternalDNS recuperando la configurazione predefinita del pacchetto:
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Dove PACKAGE-VERSION è la versione del pacchetto ExternalDNS che si desidera installare e FILE-PATH è la posizione in cui si desidera salvare il file di configurazione, ad esempio external-dns-data-values.yaml.

Configurare le impostazioni seguenti nel file external-dns-data-values.yaml. Questo file configura il pacchetto ExternalDNS.

---

# Namespace in which to deploy ExternalDNS pods.
namespace: tanzu-system-service-discovery

# Deployment-related configuration.
deployment:
args:
  - --source=service
  - --source=ingress
  - --source=contour-httpproxy # Provide this to enable Contour HTTPProxy support. Must have Contour installed or ExternalDNS will fail.
  - --domain-filter=DOMAIN # Makes ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones.
  - --policy=upsert-only # Prevents ExternalDNS from deleting any records, omit to enable full synchronization.
  - --registry=txt
  - --txt-owner-id=HOSTED-ZONE-ID
  - --txt-prefix=txt # Disambiguates TXT records from CNAME records.
  - --provider=aws
  - --aws-zone-type=public # Looks only at public hosted zones. Valid values are public, private, or no value for both.
  - --aws-prefer-cname
env:
  - name: AWS_ACCESS_KEY_ID
     valueFrom:
     secretKeyRef:
        name: route53-credentials
        key: aws_access_key_id
  - name: AWS_SECRET_ACCESS_KEY
     valueFrom:
     secretKeyRef:
        name: route53-credentials
        key: aws_secret_access_key
securityContext: {}
volumeMounts: []
volumes: []

Sostituire i segnaposto nel file external-dns-data-values.yaml con i propri valori. Per ulteriori opzioni di configurazione, vedere la documentazione relativa a ExternalDNS.

Prima di impostare opzioni di configurazione aggiuntive nel file external-dns-data-values.yaml, esaminare lo schema dei valori del pacchetto ExternalDNS. Per recuperare lo schema dei valori, eseguire:

tanzu package available get external-dns.tanzu.vmware.com/AVAILABLE-VERSION --values-schema

Dove AVAILABLE-VERSION è la versione del pacchetto ExternalDNS. Il flag --values-schema recupera la sezione valuesSchema dalla risorsa API Package per il pacchetto ExternalDNS. È possibile impostare il formato di output, --output, per lo schema dei valori su yaml, json o table. Per ulteriori informazioni, vedere Pacchetti in Installazione e gestione di pacchetti.

Server RFC2136 (BIND)

Il provider RFC2136 consente di utilizzare qualsiasi server DNS compatibile con RFC2136 come provider per ExternalDNS, ad esempio BIND.

Richiedere o creare una chiave TSIG per il server. Questa chiave deve avere l'autorizzazione ad aggiornare e trasferire la zona da aggiornare. Il formato della chiave è simile al seguente:

key "externaldns-key" {
algorithm hmac-sha256;
secret "/2avn5M4ndEztbDqy66lfQ+PjRZta9UXLtToW6NV5nM=";
};

Se si gestisce il proprio server DNS, è possibile creare una chiave TSIG utilizzando il comando tsig-keygen -a hmac-sha256 externaldns. Copiare l'output nella configurazione dei server DNS. Ad esempio, per BIND, aggiungere la chiave al file named.conf e configurare la zona con i campi allow-transfer e update-policy. Ad esempio:

key "externaldns-key" {
algorithm hmac-sha256;
secret "/2avn5M4ndEztbDqy66lfQ+PjRZta9UXLtToW6NV5nM=";
};
zone "k8s.example.org" {
type master;
file "/etc/bind/zones/k8s.zone";
      allow-transfer {
      key "externaldns-key";
      };
      update-policy {
      grant externaldns-key zonesub ANY;
      };
};

L'esempio precedente presuppone che sia anche disponibile un file di zona simile al seguente:

$TTL 60 ; 1 minute
@         IN SOA  k8s.example.org.  root.k8s.example.org. (
                  16  ; serial
                  60  ; refresh (1 minute)
                  60  ; retry (1 minute)
                  60  ; expire (1 minute)
                  60  ; minimum (1 minute)
                  )
            NS   ns.k8s.example.org.
ns           A    1.2.3.4

Creare un file di configurazione per il pacchetto ExternalDNS recuperando la configurazione predefinita del pacchetto:
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Dove PACKAGE-VERSION è la versione del pacchetto ExternalDNS che si desidera installare e FILE-PATH è la posizione in cui si desidera salvare il file di configurazione, ad esempio external-dns-data-values.yaml.

Configurare le impostazioni seguenti nel file external-dns-data-values.yaml. Questo file configura il pacchetto ExternalDNS.

---

# Namespace in which to deploy ExternalDNS pods.
namespace: tanzu-system-service-discovery

# Deployment-related configuration.
deployment:
args:
   - --source=service
   - --source=ingress
   - --source=contour-httpproxy # Provide this to enable Contour HTTPProxy support. Must have Contour installed or ExternalDNS will fail.
   - --domain-filter=DOMAIN # For example, k8s.example.org. Makes ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones.
   - --policy=upsert-only # Prevents ExternalDNS from deleting any records, omit to enable full synchronization.
   - --registry=txt
   - --txt-owner-id=k8s
   - --txt-prefix=external-dns- # Disambiguates TXT records from CNAME records.
   - --provider=rfc2136
   - --rfc2136-host=IP-ADDRESS-OF-RFC2136-DNS-SERVER
   - --rfc2136-port=53
   - --rfc2136-zone=DNS-ZONE # For example, k8s.example.org.
   - --rfc2136-tsig-secret=TSIG-SECRET-FROM-STEP-1
   - --rfc2136-tsig-secret-alg=hmac-sha256
   - --rfc2136-tsig-keyname=TSIG-KEY-NAME # For example, externaldns-key.
   - --rfc2136-tsig-axfr
env: []
securityContext: {}
volumeMounts: []
volumes: []

Sostituire i segnaposto nel file external-dns-data-values.yaml con i propri valori. Per ulteriori opzioni di configurazione, vedere la documentazione relativa a ExternalDNS.

tanzu package available get external-dns.tanzu.vmware.com/AVAILABLE-VERSION --values-schema

Azure

Per preparare il file di configurazione per la distribuzione del pacchetto ExternalDNS in Azure:

Accedere alla CLI az:
```
az login
```
Impostare la sottoscrizione:
```
az account set -s SUBSCRIPTION-ID-GUID
```

Creare un'entità servizio:

az ad sp create-for-rbac -n SERVICE-PRINCIPAL-NAME

L'output JSON del comando è simile al seguente:

{
  "appId": "a72a7cfd-7cb0-4b02-b130-03ee87e6ca89",
  "displayName": "foo",
  "name": "http://foo",
  "password": "515c55da-f909-4e17-9f52-236ffe1d3033",
  "tenant": "b35138ca-3ced-4b4a-14d6-cd83d9ea62f0"
}

Assegnare le autorizzazioni all'entità servizio:
1. Recuperare l'ID del gruppo di risorse:
```
az group show --name RESOURCE-GROUP --query id
```
2. Assegnare il ruolo con autorizzazioni di lettura all'entità servizio per l'ambito del gruppo di risorse. Sarà necessario l'appId dall'output del comando az ad sp create-for-rbac precedente.
```
az role assignment create --role "Reader" --assignee APP-ID-GUID --scope RESOURCE-GROUP-RESOURCE-ID
```
3. Recuperare l'ID della zona DNS:
```
az network dns zone show --name DNS-ZONE-NAME -g RESOURCE-GROUP-NAME --query id
```
4. Assegnare il ruolo collaboratore all'entità del servizio per l'ambito della zona DNS:
```
az role assignment create --role "Contributor" --assignee APP-ID-GUID --scope DNS-ZONE-RESOURCE-ID
```
Per connettere il servizio ExternalDNS al servizio DNS di Azure, creare un file di configurazione denominato azure.json nella macchina locale con contenuti simili al seguente:
```
{
 "tenantId": "01234abc-de56-ff78-abc1-234567890def",
 "subscriptionId": "01234abc-de56-ff78-abc1-234567890def",
 "resourceGroup": "MyDnsResourceGroup",
 "aadClientId": "01234abc-de56-ff78-abc1-234567890def",
 "aadClientSecret": "uKiuXeiwui4jo9quae9o"
}
```
Sostituire i valori nell'esempio precedente con i propri valori come indicato di seguito:
- Per recuperare tenantId, è possibile eseguire il comando az account show --query "tenantId".
- Per recuperare subscriptionId, è possibile eseguire il comando az account show --query "id".
- resourceGroup è il nome del gruppo di risorse in cui si trova la zona DNS.
- aadClientId è l'appId dall'output dell'entità servizio.
- aadClientSecret è la password dell'output dell'entità servizio.
Per rendere le credenziali di Azure disponibili per ExternalDNS, creare un segreto Kubernetes nello spazio dei nomi in cui ExternalDNS sarà in esecuzione:
1. Impostare il contesto di kubectl sul cluster in cui si distribuisce ExternalDNS. Ad esempio:
```
kubectl config use-context tkg-services-admin@tkg-services
```
2. Creare il segreto utilizzando il file di configurazione azure.json del passaggio precedente:
```
kubectl -n tanzu-system-service-discovery create secret generic azure-config-file --from-file=azure.json
```
Creare un file di configurazione per il pacchetto ExternalDNS recuperando la configurazione predefinita del pacchetto:
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Dove PACKAGE-VERSION è la versione del pacchetto ExternalDNS che si desidera installare e FILE-PATH è la posizione in cui si desidera salvare il file di configurazione, ad esempio external-dns-data-values.yaml.

Configurare le impostazioni seguenti nel file external-dns-data-values.yaml. Questo file configura il pacchetto ExternalDNS.

---

# Namespace in which to deploy ExternalDNS.
namespace: tanzu-system-service-discovery

# Deployment-related configuration.
deployment:
 args:
   - --source=service
   - --source=ingress
   - --source=contour-httpproxy # Provide this to enable Contour HTTPProxy support. Must have Contour installed or ExternalDNS will fail.
   - --domain-filter=DOMAIN # For example, k8s.example.org. Makes ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones.
   - --policy=upsert-only # Prevents ExternalDNS from deleting any records, omit to enable full synchronization.
   - --registry=txt
   - --txt-prefix=externaldns- # Disambiguates TXT records from CNAME records.
   - --provider=azure
   - --azure-resource-group=RESOURCE-GROUP # Azure resource group.
 env: []
 securityContext: {}
 volumeMounts:
   - name: azure-config-file
     mountPath: /etc/kubernetes
     readOnly: true
 volumes:
   - name: azure-config-file
     secret:
       secretName: azure-config-file

Sostituire i segnaposto nel file external-dns-data-values.yaml con i propri valori. Per ulteriori opzioni di configurazione, vedere la documentazione relativa a ExternalDNS.

tanzu package available get external-dns.tanzu.vmware.com/AVAILABLE-VERSION --values-schema

Installare il pacchetto ExternalDNS

Impostare il contesto di kubectl sul cluster in cui si distribuisce ExternalDNS. Ad esempio:
```
kubectl config use-context tkg-services-admin@tkg-services
```
Se nel cluster non è installato un repository dei pacchetti con il pacchetto ExternalDNS, ad esempio il repository tanzu-standard, installarne uno:
```
tanzu package repository add PACKAGE-REPO-NAME --url PACKAGE-REPO-ENDPOINT --namespace tkg-system
```
In cui:
- PACKAGE-REPO-NAME è il nome del repository dei pacchetti, ad esempio tanzu-standard o il nome di un registro immagini privato configurato con le variabili ADDITIONAL_IMAGE_REGISTRY.
- PACKAGE-REPO-ENDPOINT è l'URL del repository dei pacchetti.
  - Per questa versione, l'URL di tanzu-standard è projects.registry.vmware.com/tkg/packages/standard/repo:v2023.10.16. Vedere Elenco dei repository dei pacchetti per ottenere questo valore dalla CLI di Tanzu oppure in Tanzu Mission Control vedere l'elenco Elementi aggiuntivi (Addons) > Repository (Repositories) nel riquadro Cluster.
Recuperare il nome del pacchetto ExternalDNS:
```
tanzu package available list -A
```

Recuperare la versione del pacchetto ExternalDNS:

tanzu package available list external-dns.tanzu.vmware.com -A

Se il file external-dns-data-values.yaml contiene commenti, rimuoverli prima di installare il pacchetto:
```
yq -i eval '... comments=""' external-dns-data-values.yaml
```
Installare il pacchetto:
```
tanzu package install external-dns \
--package external-dns.tanzu.vmware.com \
--version AVAILABLE-PACKAGE-VERSION \
--values-file external-dns-data-values.yaml \
--namespace TARGET-NAMESPACE
```
In cui:
- TARGET-NAMESPACE è lo spazio dei nomi in cui si desidera installare il pacchetto ExternalDNS. Ad esempio, lo spazio dei nomi my-packages o tanzu-cli-managed-packages.
  - Se il flag --namespace non viene specificato, la CLI di Tanzu installa il pacchetto nello spazio dei nomi default. I pod ExternalDNS e tutte le altre risorse associate al componente ExternalDNS vengono create nello spazio dei nomi tanzu-system-service-discovery; non installare il pacchetto ExternalDNS in questo spazio dei nomi.
  - Lo spazio dei nomi specificato deve essere già stato creato, ad esempio eseguendo kubectl create namespace my-packages.
- AVAILABLE-PACKAGE-VERSION è la versione recuperata in precedenza.
Ad esempio:
```
tanzu package install external-dns \
--package external-dns.tanzu.vmware.com \
--version 0.10.0+vmware.1-tkg.1 \
--values-file external-dns-data-values.yaml \
--namespace my-packages
```
Verificare che il pacchetto external-dns sia stato installato:
```
tanzu package installed list -A
```
Per visualizzare ulteriori dettagli sul pacchetto, è inoltre possibile eseguire:
```
tanzu package installed get external-dns --namespace PACKAGE-NAMESPACE
```
Dove PACKAGE-NAMESPACE è lo spazio dei nomi in cui è installato il pacchetto external-dns.
Verificare che l'app external-dns sia stata riconciliata correttamente in PACKAGE-NAMESPACE:
```
kubectl get apps -A
```
Se lo stato non è Reconcile Succeeded, visualizzare i dettagli completi dello stato dell'app external-dns. La visualizzazione dello stato completo può aiutare a risolvere il problema.
```
kubectl get app external-dns --namespace PACKAGE-NAMESPACE -o yaml
```
Dove PACKAGE-NAMESPACE è lo spazio dei nomi in cui è stato installato il pacchetto. Se la risoluzione dei problemi non consente di risolvere il problema, è necessario disinstallare il pacchetto prima di installarlo di nuovo:
```
tanzu package installed delete external-dns --namespace PACKAGE-NAMESPACE
```
Verificare che i pod ExternalDNS siano in esecuzione nello spazio dei nomi tanzu-system-service-discovery:
```
kubectl get pods -A
```

Convalida di ExternalDNS

Se configurato con Contour, ExternalDNS controllerà automaticamente lo spazio dei nomi specificato per le risorse HTTPProxy e creerà record DNS per i servizi con nomi host che corrispondono al filtro di dominio configurato.

ExternalDNS controllerà automaticamente i servizi Kubernetes con l'annotazione external-dns.alpha.kubernetes.io/hostname e creerà record DNS per i servizi le cui annotazioni corrispondono al filtro di dominio configurato.

Ad esempio, per un servizio con l'annotazione external-dns.alpha.kubernetes.io/hostname: foo.k8s.example.org, ExternalDNS creerà un record DNS per foo.k8s.example.org. È possibile verificare l'esistenza del record esaminando la zona creata.

Aggiornamento di una distribuzione ExternalDNS in esecuzione

Se è necessario apportare modifiche alla configurazione del pacchetto ExternalDNS dopo la distribuzione, seguire queste istruzioni per aggiornare il pacchetto ExternalDNS distribuito.

Aggiornare la configurazione ExternalDNS in external-dns-data-values.yaml.

Aggiornare la configurazione del pacchetto installato:

tanzu package installed update external-dns \
--version INSTALLED-PACKAGE-VERSION \
--values-file external-dns-data-values.yaml \
--namespace INSTALLED-PACKAGE-NAMESPACE

In cui:

INSTALLED-PACKAGE-VERSION è la versione del pacchetto ExternalDNS installato.
INSTALLED-PACKAGE-NAMESPACE è lo spazio dei nomi in cui è installato il pacchetto ExternalDNS.

Ad esempio:

tanzu package installed update external-dns \
--version 0.10.0+vmware.1-tkg.1 \
--values-file external-dns-data-values.yaml \
--namespace my-packages

Il pacchetto ExternalDNS verrà riconciliato utilizzando il nuovo valore o i valori aggiunti. L'applicazione delle modifiche da parte di kapp-controller può richiedere fino a cinque minuti.

Per ulteriori informazioni sul comando tanzu package installed update, vedere Aggiornamento di un pacchetto in Installazione e gestione di pacchetti È possibile utilizzare questo comando per aggiornare la versione o la configurazione di un pacchetto installato.