Utiliser TLS avec un contrôleur d’entrée sur Azure Kubernetes Service (AKS)

Le protocole TLS (Transport Layer Security) utilise des certificats pour assurer la sécurité de la communication, du chiffrement, de l’authentification et de l’intégrité. L’utilisation du protocole TLS avec un contrôleur d’entrée sur AKS vous permet de sécuriser la communication entre vos applications et de bénéficier des avantages d’un contrôleur d’entrée.

Vous pouvez apporter vos propres certificats et les intégrer au pilote CSI du magasin des secrets. Vous pouvez aussi utiliser cert-manager, qui génère et configure automatiquement des certificats Let’s Encrypt. Deux applications s’exécutent dans le cluster AKS, chacune étant accessible par la biais d’une seule adresse IP.

Avant de commencer

• Cet article suppose également que vous disposez d’un contrôleur d’entrée et d’applications configurés. Si vous avez besoin d’un contrôleur d’entrée ou d’un exemple d’applications, consultez Créer un contrôleur d’entrée.

• Cet article utilise Helm 3 pour installer le contrôleur d’entrée Nginx sur une version prise en charge de Kubernetes. Vérifiez que vous utilisez la version la plus récente de Helm et que vous avez accès aux dépôts Helm ingress-nginx et jetstack. Les étapes décrites dans cet article peuvent ne pas être compatibles avec les versions précédentes du Helm Chart, NGINX Ingres Controller ou Kubernetes.

  • Pour plus d’informations sur la configuration et l’utilisation de Helm, consultez Installer des applications avec Helm dans AKS. Pour obtenir des instructions de mise à niveau, consultez la documentation d’installation de Helm.

• Cet article suppose que vous disposez d’un cluster AKS existant avec un ACR (Azure Container Registry) intégré. Pour plus d’informations sur la création d’un cluster AKS avec un ACR intégré, consultez S’authentifier avec ACR à partir d’AKS.

• Si vous utilisez Azure CLI, cet article nécessite que vous exécutiez Azure CLI version 2.0.64 ou ultérieure. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.

• Si vous utilisez Azure PowerShell, cet article nécessite que vous exécutiez Azure PowerShell version 5.9.0 ou ultérieure. Exécutez Get-InstalledModule -Name Az pour trouver la version. Si vous avez besoin de procéder à une installation ou à une mise à niveau, consultez Installer Azure PowerShell.

Utiliser TLS avec vos propres certificats avec le pilote CSI du magasin des secrets

Pour utiliser TLS avec vos propres certificats avec le pilote CSI du magasin de secrets, vous avez besoin d’un cluster AKS avec le pilote CSI du magasin des secrets configuré et d’une instance Azure Key Vault.

Pour plus d’informations, consultez Configurer le pilote CSI du magasin des secrets pour activer le contrôleur d’entrée NGINX avec TLS.

Utiliser TLS avec des certificats Let’s Encrypt

Pour utiliser TLS avec des certificats Let’s Encrypt, vous allez déployer cert-manager, qui génère et configure automatiquement des certificats Let’s Encrypt.

Importer les images du gestionnaire de certificats utilisées par le chart Helm dans votre ACR

Options de configuration du contrôleur d’entrée

Vous pouvez configurer votre contrôleur d’entrée NGINX à l’aide d’une adresse IP publique statique ou d’une adresse IP publique dynamique. Si vous utilisez un domaine personnalisé, vous avez besoin d’ajouter un enregistrement A à votre zone DNS. Si vous n’utilisez pas de domaine personnalisé, vous pouvez configurer un nom de domaine complet (FQDN) pour l’adresse IP du contrôleur d’entrée.

Créer une adresse IP publique statique ou dynamique

Utiliser une adresse IP publique statique

Vous pouvez configurer votre contrôleur d’entrée avec une adresse IP publique statique. L’adresse IP publique statique reste si vous supprimez votre contrôleur d’entrée. L’adresse IP ne reste pas si vous supprimez votre cluster AKS.

Lorsque vous mettez à niveau votre contrôleur d’entrée, vous devez passer un paramètre à la version Helm pour vous assurer que le service du contrôleur d’entrée est informé de l’équilibreur de charge qui lui sera alloué. Pour que les certificats HTTPS fonctionnent correctement, vous utilisez une étiquette DNS pour configurer un FQDN pour l'adresse IP du contrôleur d'entrée.

Pour plus d’informations, consultez Utiliser une adresse IP publique statique et une étiquette DNS avec l’équilibreur de charge AKS.

Utiliser une adresse IP publique dynamique

Une adresse IP publique Azure est créée pour votre contrôleur d’entrée lors de sa création. Cette adresse IP publique est statique pendant la durée de vie de votre contrôleur d’entrée. L’adresse IP publique ne reste pas si vous supprimez votre contrôleur d’entrée. Si vous créez un contrôleur d’entrée, une nouvelle adresse IP publique lui est attribuée. Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit.

• Utilisez la commande kubectl get servicepour obtenir l’adresse IP publique de votre contrôleur d’entrée.

  # 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
  

Ajouter un enregistrement A à votre zone DNS

Si vous utilisez un domaine personnalisé, vous avez besoin d’ajouter un enregistrement A à votre zone DNS. Si vous n’utilisez pas de domaine personnalisé, vous pouvez configurer l’adresse IP publique avec un nom de domaine complet.

Configurer un nom de domaine complet pour votre contrôleur d’entrée

Si vous le souhaitez, vous pouvez configurer un nom de domaine complet pour l’adresse IP du contrôleur d’entrée au lieu d’un domaine personnalisé par une étiquette DNS. Votre nom de domaine complet doit suivre la forme suivante : <CUSTOM DNS LABEL>.<AZURE REGION NAME>.cloudapp.azure.com.

Vous pouvez configurer votre FQDN en utilisant l’une des méthodes suivantes :

• Définition de l’étiquette DNS en utilisant Azure CLI ou Azure PowerShell.
• Définition de l’étiquette DNS à l’aide des paramètres du chart Helm.

Pour plus d’informations, consultez Étiquettes de nom DNS d’adresse IP publique.

Définition de l’étiquette DNS en utilisant Azure CLI ou Azure PowerShell

Veillez à remplacer <DNS_LABEL> par votre étiquette DNS unique.

# 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

Définition de l’étiquette DNS à l’aide des paramètres du chart Helm

Vous pouvez transmettre un paramètre d'annotation à la configuration de votre graphique Helm en utilisant le paramètre--set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name". Ce paramètre peut être défini lors du premier déploiement du contrôleur d’entrée ou être configuré ultérieurement.

L’exemple suivant montre comment mettre à jour ce paramètre après le déploiement du contrôleur. Veillez à remplacer <DNS_LABEL> par votre étiquette DNS unique.

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

Installer cert-manager

Le contrôleur d’entrée NGINX prend en charge l’arrêt TLS. Il existe plusieurs façons de récupérer et de configurer des certificats pour le protocole HTTPS. Cet article utilise cert-manager, qui permet de générer et gérer automatiquement des certificats Let’s Encrypt.

Pour installer le contrôleur cert-manager, utilisez les commandes suivantes.

# 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

Pour plus d’informations sur la configuration cert-manager, voir le projet cert-manager.

Créer un émetteur de cluster d’autorité de certification

Pour pouvoir émettre des certificats, cert-manager a besoin de l’un des émetteurs suivants :

• Un émetteur, qui fonctionne dans un espace de noms unique.
• Une ressource ClusterIssuer, qui fonctionne dans tous les espaces de noms.

Pour plus d’informations, voir la documentation de l’émetteur cert-manager.

1. Créez un émetteur de cluster, tel que cluster-issuer.yaml, avec l’exemple de manifeste suivant. Remplacez MY_EMAIL_ADDRESS par une adresse valide de votre 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
   

2. Appliquez l’émetteur à l’aide de la commande kubectl apply.

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

Mettre à jour vos routes d’entrée

Vous avez besoin de mettre à jour vos routes d’entrée pour gérer le trafic vers votre nom de domaine complet ou votre domaine personnalisé.

Dans l’exemple suivant, le trafic est routé ainsi :

• Le trafic vers hello-world-ingress.MY_CUSTOM_DOMAIN est routé vers le service aks-helloworld-one.
• Le trafic vers hello-world-ingress.MY_CUSTOM_DOMAIN/hello-world-two est routé vers le service aks-helloworld-two.
• Le trafic vers hello-world-ingress.MY_CUSTOM_DOMAIN/static est acheminé vers le service nommé aks-helloworld-one pour les ressources statiques.

1. Créez ou mettez à jour le fichier hello-world-ingress.yaml à l’aide de l’exemple de fichier YAML suivant. Mettez à jour les valeurs de spec.tls.hosts et de spec.rules.host avec le nom DNS que vous avez créé à l’étape précédente.

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

2. Mettez à jour la ressource d’entrée en utilisant la commande kubectl apply.

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

Vérifier qu’un objet de certificat a été créé

Il faut ensuite créer une ressource de certificat. Elle définit le certificat X.509 souhaité. Pour plus d’informations, consultez Certificats cert-manager.

cert-manager crée automatiquement un objet de certificat à l’aide d’ingress-shim ; le certificat est automatiquement déployé avec cert-manager depuis la version 0.2.2. Pour plus d’informations, consultez la documentation d’ingress-shim.

Pour vérifier que le certificat a été correctement créé, utilisez la commande kubectl get certificate --namespace ingress-basic et vérifiez que READY a la valeur True. L’obtention de la sortie peut prendre plusieurs minutes.

kubectl get certificate --namespace ingress-basic

La sortie suivante indique l’état du certificat.

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

Tester la configuration d’entrée

Ouvrez un navigateur web sur hello-world-ingress.MON_DOMAINE_PERSONNALISÉ ou sur le nom de domaine complet de votre contrôleur d’entrée Kubernetes. Vérifiez que les conditions suivantes sont remplies :

• Vous êtes redirigé vers une utilisation de HTTPS.
• Le certificat est approuvé.
• L’application de démonstration s’affiche dans le navigateur web.
• Ajoutez /hello-world-two à la fin du domaine et vérifiez que la seconde application de démonstration s’affiche avec le titre personnalisé.

Nettoyer les ressources

Cet article vous a montré comment utiliser Helm pour installer les composants d’entrée, les certificats et les exemples d’applications. Quand vous déployez un chart Helm, plusieurs ressources Kubernetes sont créées. Ces ressources incluent des pods, des déploiements et des services. Pour nettoyer ces ressources, vous pouvez supprimer l’exemple d’espace de noms dans son ensemble ou des ressources individuelles.

Supprimer l’espace de noms exemple et toutes les ressources

La suppression de l’exemple d’espace de noms supprime également toutes ses ressources.

• Supprimez l’espace de noms exemple en entier en utilisant la commande kubectl delete et en spécifiant le nom de votre espace de noms.

  kubectl delete namespace ingress-basic
  

Supprimer les ressources individuellement

Vous pouvez également supprimer la ressource individuellement.

1. Supprimez les ressources de l’émetteur de cluster.

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

2. Listez les versions de Helm avec la commande helm list. Recherchez les charts nommés nginx et cert-manager, comme illustré dans l’exemple de sortie suivant.

   $ helm list --namespace ingress-basic
   
   NAME                    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
   cert-manager            ingress-basic   1               2020-01-15 10:23:36.515514 -0600 CST    deployed        cert-manager-v0.13.0    v0.13.0
   nginx                   ingress-basic   1               2020-01-15 10:09:45.982693 -0600 CST    deployed        nginx-ingress-1.29.1    0.27.0
   

3. Désinstallez les versions avec la commande helm uninstall. L’exemple suivant désinstalle les déploiements d’entrée et de gestionnaire de certificats NGINX.

   $ helm uninstall cert-manager nginx --namespace ingress-basic
   
   release "cert-manager" uninstalled
   release "nginx" uninstalled
   

4. Supprimez les deux exemples d’applications.

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

5. Supprimez la route d’entrée qui a dirigé le trafic vers les exemples d’applications.

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

6. Supprimez l’espace de noms lui-même. Utilisez la commande kubectl delete et spécifiez le nom de votre espace de noms.

   kubectl delete namespace ingress-basic
   

Étapes suivantes

Cet article a mentionné certains composants qui n’appartiennent pas à AKS. Pour plus d’informations sur ces composants, consultez les pages projet suivantes :

• Interface CLI Helm
• Contrôleur d’entrée NGINX
• cert-manager

Vous pouvez également :

• Routage d’applications HTTP