Installer ExternalDNS pour la détection de services

Cette rubrique explique comment déployer ExternalDNS dans un cluster de charge de travail dans Tanzu Kubernetes Grid.

Le service ExternalDNS publie des enregistrements DNS pour les applications sur les serveurs DNS, à l'aide d'une interface Kubernetes déclarative native. Il se présente sous la forme d'un module géré par l'interface de ligne de commande dans Tanzu Kubernetes Grid.

Dans les environnements dans lesquels Harbor est déployé dans un cluster de services partagés avec équilibrage de charge (AWS, Azure et vSphere avec NSX Advanced Load Balancer), ExternalDNS peut être utilisé pour publier un nom d'hôte DNS pour le service Harbor. Cela permet d'accéder à Harbor à partir d'autres clusters. Pour plus d'informations, reportez-vous à la section Registre Harbor et ExternalDNS.

Conditions requises

Une machine de démarrage avec les éléments suivants installés :
- La CLI Tanzu, les plug-ins de CLI Tanzu et kubectl, comme décrit dans Installer la CLI Tanzu et d'autres outils à utiliser avec un superviseur vSphere with Tanzu ou Installer la CLI Tanzu et d'autres outils à utiliser avec les clusters de gestion autonomes.
- Les outils Carvel, comme décrit dans Installer les outils Carvel.
- yq v4.5 ou version ultérieure.
Vous avez déployé un cluster de gestion sur vSphere, Amazon Web Services (AWS) ou Azure, dans un environnement connecté à Internet ou à accès restreint à Internet. Si vous utilisez Tanzu Kubernetes Grid dans un environnement à accès restreint à Internet, vous avez effectué la procédure dans Préparer le déploiement de clusters de gestion dans un environnement à accès restreint à Internet avant de déployer le cluster de gestion.
Vous vous êtes connecté à la CLI Tanzu à l'aide de la commande tanzu login.
Vous avez déterminé les noms de domaine complets (FQDN) des services que vous souhaitez exposer avec ExternalDNS à votre serveur DNS.

Préparer le cluster pour le déploiement ExternalDNS

Le service ExternalDNS doit être déployé dans le même cluster que les services pour lesquels il exportera les enregistrements DNS.

Pour installer Harbor, suivez les conditions préalables et la procédure décrites dans la section Installer Harbor pour le registre de service.
ExternalDNS prend en charge la création d'enregistrements pour les services Kubernetes et les ressources HTTPProxy Contour. Si vous souhaitez créer des enregistrements pour les ressources HTTPProxy Contour dans un cluster de charge de travail, vous devez installer le module Contour dans le cluster. Pour obtenir des instructions, reportez-vous à la section Installer Contour pour le contrôle d'entrée. Le module Contour est également requis par Harbor.

Préparer le fichier de configuration pour le module ExternalDNS

Le module ExternalDNS a été validé avec AWS (Route 53), Azure DNS et RFC2136 (BIND). La configuration fournie exporte des enregistrements pour les ressources HTTPProxy Contour et les Services Kubernetes de type LoadBalancer.

La communauté DNS externe maintient les intégrations avec de nombreux fournisseurs DNS à différents niveaux de stabilité. Sauf indication contraire, VMware ne garantit pas la prise en charge de l'intégration du module ExternalDNS à des fournisseurs spécifiques.

AWS (Route 53)

Pour préparer le fichier de configuration afin de déployer le module ExternalDNS sur AWS,

Créez une zone hébergée dans Route 53 avec le domaine que vos services utiliseront.
Enregistrez l'ID de la zone hébergée (Hosted zone ID). Vous utiliserez cet ID ultérieurement, lors de la configuration d'ExternalDNS.
Créez une stratégie IAM pour ExternalDNS afin de permettre à ExternalDNS de mettre à jour Route 53. Dans la console AWS, accédez au tableau de bord IAM et, sous Gestion des accès (Access Management), accédez à l'écran Stratégies (Policies). Cliquez sur Créer une stratégie (Create Policy) et passez à l'onglet JSON. Collez la stratégie suivante. Si nécessaire, vous pouvez affiner la stratégie pour autoriser les mises à jour de la zone hébergée que vous venez de créer. Terminez l'assistant.
```
{
 "Version": "2012-10-17",
 "Statement": [
   {
     "Effect": "Allow",
     "Action": [
       "route53:ChangeResourceRecordSets"
     ],
     "Resource": [
       "arn:aws:route53:::hostedzone/*"
     ]
   },
   {
     "Effect": "Allow",
     "Action": [
       "route53:ListHostedZones",
       "route53:ListResourceRecordSets"
     ],
     "Resource": [
       "*"
     ]
   }
 ]
}
```
Créez un utilisateur IAM pour ExternalDNS avec la stratégie que vous avez créée ci-dessus. Dans la console AWS, accédez à l'écran Utilisateurs (Users) et cliquez sur Ajouter des utilisateurs (Add users). Fournissez un nom pour l'utilisateur IAM et assurez-vous qu'Accès programmatique (Programmatic access) est activé. Sur l'écran Autorisations (Permissions) de l'assistant, cliquez sur Attacher les stratégies existantes directement (Attach existing policies directly) et sélectionnez la stratégie que vous avez créée à l'étape précédente.
Passez à la dernière page de l'assistant. Enregistrez l'ID de clé d'accès (Access key ID) et le Secret de clé d'accès (Secret access key). Pour rendre ces informations d'identification Route 53 disponibles pour ExternalDNS, créez un secret Kubernetes dans l'espace de noms dans lequel ExternalDNS s'exécutera.
1. Définissez le contexte de kubectl sur le cluster sur lequel vous déployez ExternalDNS. Par exemple :
```
kubectl config use-context tkg-services-admin@tkg-services
```
2. Créez le secret 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
```
  Où YOUR-ACCESS-KEY-ID et YOUR-SECRET-ACCESS-KEY sont les informations d'identification que vous avez enregistrées ci-dessus.
Créez un fichier de configuration pour le module ExternalDNS en récupérant la configuration par défaut du module :
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Où PACKAGE-VERSION est la version du module ExternalDNS que vous souhaitez installer et FILE-PATH est l'emplacement dans lequel vous souhaitez enregistrer le fichier de configuration (par exemple, external-dns-data-values.yaml).

Configurez les paramètres suivants dans le fichier external-dns-data-values.yaml. Ce fichier configure le module 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: []

Remplacez les espaces réservés du fichier external-dns-data-values.yaml par vos valeurs. Pour plus d'options de configuration, reportez-vous à la documentation ExternalDNS.

Avant de définir des options de configuration supplémentaires dans le fichier external-dns-data-values.yaml, vérifiez le schéma de valeurs du module ExternalDNS. Pour récupérer le schéma de valeurs, exécutez :

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

Où AVAILABLE-VERSION est la version du module ExternalDNS. L'indicateur --values-schema récupère la section valuesSchema de la ressource d'API Package pour le module ExternalDNS. Vous pouvez définir le format de sortie (--output) pour le schéma de valeurs sur yaml, json ou table. Pour plus d'informations, reportez-vous à la section Modules dans Installer et gérer les modules.

Serveur RFC2136 (BIND)

Le fournisseur RFC2136 vous permet d'utiliser n'importe quel serveur DNS compatible avec RFC2136 en tant que fournisseur pour ExternalDNS, tel que BIND.

Demandez ou créez une clé TSIG pour votre serveur. Cette clé doit être autorisée à mettre à jour et à transférer la zone que vous souhaitez mettre à jour. Le clé est semblable à l'exemple suivant :

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

Si vous gérez votre propre serveur DNS, vous pouvez créer une clé TSIG à l'aide de la commande tsig-keygen -a hmac-sha256 externaldns. Copiez la sortie dans la configuration de vos serveurs DNS. Par exemple, pour BIND, ajoutez la clé au fichier named.conf et configurez la zone avec les champs allow-transfer et update-policy. Par exemple :

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;
      };
};

Les éléments ci-dessus supposent que vous disposez également d'un fichier de zone qui peut ressembler à ce qui suit :

$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

Créez un fichier de configuration pour le module ExternalDNS en récupérant la configuration par défaut du module :
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Où PACKAGE-VERSION est la version du module ExternalDNS que vous souhaitez installer et FILE-PATH est l'emplacement dans lequel vous souhaitez enregistrer le fichier de configuration (par exemple, external-dns-data-values.yaml).

Configurez les paramètres suivants dans le fichier external-dns-data-values.yaml. Ce fichier configure le module 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: []

Remplacez les espaces réservés du fichier external-dns-data-values.yaml par vos valeurs. Pour plus d'options de configuration, reportez-vous à la documentation ExternalDNS.

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

Azure

Pour préparer le fichier de configuration afin de déployer le module ExternalDNS sur Azure,

Connectez-vous à l'interface de ligne de commande az :
```
az login
```
Définissez votre abonnement :
```
az account set -s SUBSCRIPTION-ID-GUID
```

Créez un principal de service :

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

La sortie JSON de la commande ressemble à ce qui suit :

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

Attribuez des autorisations au principal de service :
1. Récupérez l'ID du groupe de ressources :
```
az group show --name RESOURCE-GROUP --query id
```
2. Attribuez le rôle de lecteur au principal de service pour l'étendue du groupe de ressources. Vous aurez besoin de l'appId de la sortie de la commande az ad sp create-for-rbac ci-dessus.
```
az role assignment create --role "Reader" --assignee APP-ID-GUID --scope RESOURCE-GROUP-RESOURCE-ID
```
3. Récupérez l'ID de la zone DNS :
```
az network dns zone show --name DNS-ZONE-NAME -g RESOURCE-GROUP-NAME --query id
```
4. Attribuez le rôle de contributeur au principal de service pour l'étendue de la zone DNS :
```
az role assignment create --role "Contributor" --assignee APP-ID-GUID --scope DNS-ZONE-RESOURCE-ID
```
Pour connecter le service ExternalDNS au service Azure DNS, vous créez un fichier de configuration nommé azure.json sur votre machine locale avec un contenu semblable à celui-ci :
```
{
 "tenantId": "01234abc-de56-ff78-abc1-234567890def",
 "subscriptionId": "01234abc-de56-ff78-abc1-234567890def",
 "resourceGroup": "MyDnsResourceGroup",
 "aadClientId": "01234abc-de56-ff78-abc1-234567890def",
 "aadClientSecret": "uKiuXeiwui4jo9quae9o"
}
```
Remplacez les valeurs dans l'exemple ci-dessus par vos propres valeurs comme suit :
- Pour récupérer tenantId, vous pouvez exécuter la commande az account show --query "tenantId".
- Pour récupérer subscriptionId, vous pouvez exécuter la commande az account show --query "id".
- resourceGroup est le nom du groupe de ressources dans lequel se trouve votre zone DNS.
- aadClientId est l'appId de la sortie du principal de service.
- aadClientSecret est le mot de passe provenant de la sortie du principal de service.
Pour rendre vos informations d'identification Azure disponibles pour ExternalDNS, créez un secret Kubernetes dans l'espace de noms dans lequel ExternalDNS s'exécutera :
1. Définissez le contexte de kubectl sur le cluster sur lequel vous déployez ExternalDNS. Par exemple :
```
kubectl config use-context tkg-services-admin@tkg-services
```
2. Créez le secret à l'aide du fichier de configuration azure.json de l'étape précédente :
```
kubectl -n tanzu-system-service-discovery create secret generic azure-config-file --from-file=azure.json
```
Créez un fichier de configuration pour le module ExternalDNS en récupérant la configuration par défaut du module :
```
tanzu package available get external-dns.tanzu.vmware.com/PACKAGE-VERSION --default-values-file-output FILE-PATH
```
Où PACKAGE-VERSION est la version du module ExternalDNS que vous souhaitez installer et FILE-PATH est l'emplacement dans lequel vous souhaitez enregistrer le fichier de configuration (par exemple, external-dns-data-values.yaml).

Configurez les paramètres suivants dans le fichier external-dns-data-values.yaml. Ce fichier configure le module 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

Remplacez les espaces réservés du fichier external-dns-data-values.yaml par vos valeurs. Pour plus d'options de configuration, reportez-vous à la documentation ExternalDNS.

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

Installer le module ExternalDNS

Définissez le contexte de kubectl sur le cluster sur lequel vous déployez ExternalDNS. Par exemple :
```
kubectl config use-context tkg-services-admin@tkg-services
```
Si vous ne l'avez pas encore fait, ajoutez le référentiel de modules standard au cluster :

Remarque
Si vous ciblez un cluster basé sur un plan (hérité), ignorez cette étape. Pour les clusters basés sur un plan, le référentiel de modules tanzu-standard est automatiquement activé dans chaque cluster, dans l'espace de noms tanzu-package-repo-global.
```
tanzu package repository add tanzu-standard --url PACKAGE-REPOSITORY-ENDPOINT --namespace tkg-system
```
Où PACKAGE-REPOSITORY-ENDPOINT est l'URL du référentiel de modules standard. Pour cette version, l'URL est projects.registry.vmware.com/tkg/packages/standard/repo:v2.1.1.

Reportez-vous à la section Répertorier les référentiels de modules (List Package Repositories) pour obtenir cette valeur depuis la CLI Tanzu ou, dans Tanzu Mission Control, consultez la liste Modules complémentaires (Addons) > Référentiels (Repositories) dans le volet Cluster.
Récupérez le nom du module ExternalDNS :
```
tanzu package available list -A
```

Récupérez la version du module ExternalDNS :

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

Si votre fichier external-dns-data-values.yaml contient des commentaires, supprimez-les avant d'installer le module :
```
yq -i eval '... comments=""' external-dns-data-values.yaml
```
Installez le module :
```
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
```
Où :
- TARGET-NAMESPACE est l'espace de noms dans lequel vous souhaitez installer le module ExternalDNS. Par exemple, l'espace de noms my-packages ou tanzu-cli-managed-packages.
  - Si l'indicateur --namespace n'est pas spécifié, la CLI Tanzu installe le module dans l'espace de noms default. Les espaces ExternalDNS et toutes les autres ressources associées au composant ExternalDNS sont créés dans l'espace de noms tanzu-system-service-discovery. N'installez pas le module ExternalDNS dans cet espace de noms.
  - L'espace de noms spécifié doit déjà exister, par exemple en exécutant kubectl create namespace my-packages.
- AVAILABLE-PACKAGE-VERSION est la version que vous avez récupérée ci-dessus.
Par exemple :
```
tanzu package install external-dns \
--package external-dns.tanzu.vmware.com \
--version 0.8.0+vmware.1-tkg.1 \
--values-file external-dns-data-values.yaml \
--namespace my-packages
```
Vérifiez que le module external-dns a été installé :
```
tanzu package installed list -A
```
Pour afficher plus de détails sur le module, vous pouvez également exécuter :
```
tanzu package installed get external-dns --namespace PACKAGE-NAMESPACE
```
Où PACKAGE-NAMESPACE est l'espace de noms dans lequel le module external-dns est installé.
Vérifiez que l'application external-dns a été rapprochée de votre espace PACKAGE-NAMESPACE :
```
kubectl get apps -A
```
Si l'état n'est pas Reconcile Succeeded, affichez les détails de l'état complet de l'application external-dns. L'affichage de l'état complet peut vous aider à résoudre le problème.
```
kubectl get app external-dns --namespace PACKAGE-NAMESPACE -o yaml
```
Où PACKAGE-NAMESPACE est l'espace de noms dans lequel vous avez installé le module. Si le dépannage ne vous aide pas à résoudre le problème, vous devez désinstaller le module avant de le réinstaller :
```
tanzu package installed delete external-dns --namespace PACKAGE-NAMESPACE
```
Vérifiez que les espaces ExternalDNS s'exécutent dans l'espace de noms tanzu-system-service-discovery :
```
kubectl get pods -A
```

Validation d'ExternalDNS

S'il est configuré avec Contour, ExternalDNS surveillera automatiquement l'espace de noms spécifié pour les ressources HTTPProxy et crée des enregistrements DNS pour les services avec des noms d'hôte correspondant au filtre de domaine configuré.

En outre, ExternalDNS surveillera automatiquement les services Kubernetes avec l'annotation external-dns.alpha.kubernetes.io/hostname et crée des enregistrements DNS pour les services dont les annotations correspondent au filtre de domaine configuré.

Par exemple, pour un service avec l'annotation external-dns.alpha.kubernetes.io/hostname: foo.k8s.example.org, ExternalDNS créera un enregistrement DNS pour foo.k8s.example.org. Vous pouvez valider l'existence de l'enregistrement en examinant la zone que vous avez créée.

Mettre à jour un déploiement ExternalDNS en cours d'exécution

Si vous devez apporter des modifications à la configuration du module ExternalDNS après le déploiement, suivez ces étapes pour mettre à jour votre module ExternalDNS déployé.

Mettez à jour la configuration ExternalDNS dans external-dns-data-values.yaml.

Mettez à jour la configuration du module installé :

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

Où :

INSTALLED-PACKAGE-VERSION est la version du module ExternalDNS installé.
INSTALLED-PACKAGE-NAMESPACE est l'espace de noms dans lequel le module ExternalDNS est installé.

Par exemple :

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

Le module ExternalDNS sera rapproché à l'aide de la nouvelle valeur ou des nouvelles valeurs que vous avez ajoutées. L'application des modifications pour kapp-controller peut prendre jusqu'à cinq minutes.

Pour plus d'informations sur la commande tanzu package installed update, reportez-vous à la section Mettre à jour un module dans Installer et gérer des modules. Vous pouvez utiliser cette commande pour mettre à jour la version ou la configuration d'un module installé.