Tutoriel : Configurer les rôles de contrôle d’accès en fonction du rôle (RBAC) dans Azure Kubernetes Service (AKS) à l’aide d’Ansible

Important

Ansible 2.8 (ou version ultérieure) est nécessaire pour exécuter les exemples de playbooks dans cet article.

Azure Kubernetes Service (AKS) simplifie le déploiement dans Azure d’un cluster Kubernetes managé. AKS permet de réduire la complexité et la surcharge opérationnelle de la gestion d’un cluster Kubernetes en déléguant une grande partie de cette responsabilité à Azure. En tant que service Kubernetes hébergé, Azure gère pour vous des tâches critiques telles que l’analyse de l'intégrité et la maintenance. Les maîtres Kubernetes sont gérés par Azure. Vous gérez uniquement les nœuds de l’agent. En tant que service Kubernetes managé, AKS est gratuit. Vous payez uniquement pour les nœuds de l’agent au sein de vos clusters, pas pour les maîtres.

AKS peut être configuré pour utiliser Azure Active Directory (AD) pour l’authentification utilisateur. Une fois configuré, votre jeton d’authentification Azure AD vous permet de vous connecter au cluster AKS. Le RBAC peut être basé sur l’identité d’un utilisateur ou l’appartenance à un groupe de répertoire.

Dans cet article, vous apprendrez comment :

  • Créer un cluster AKS compatible Azure AD
  • Configurer un rôle RBAC dans le cluster

Prérequis

  • Abonnement Azure : Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
  • Installer la bibliothèque RedHat OpenShift - pip install openshift

Configurer Azure AD pour l’authentification AKS

Lorsque vous configurez Azure AD pour l’authentification AKS, deux applications Azure AD sont configurées. Cette opération doit être effectuée par un administrateur de locataire Azure. Pour plus d’informations, consultez Intégrer Azure Active Directory avec AKS.

À partir de l’administrateur du locataire Azure, obtenez les valeurs suivantes :

  • Secret de l’application serveur
  • ID de l’application serveur
  • ID de l’application cliente
  • ID client

Ces valeurs sont nécessaires pour exécuter l’exemple de playbook.

Créer un cluster AKS

Dans cette section, vous créez un service AKS avec l’application Azure AD.

Voici quelques remarques importantes à prendre en compte lorsque vous travaillez avec l’exemple de playbook :

  • Le playbook charge ssh_key à partir de ~/.ssh/id_rsa.pub. Si vous le modifiez, utilisez le format single-line en commençant par « ssh-rsa » (sans les guillemets).

  • Les valeurs client_id et client_secret sont chargées à partir de ~/.azure/credentials, qui est le fichier d’informations d’identification par défaut. Vous pouvez définir ces valeurs pour votre service principal ou les charger à partir de variables d’environnement :

    client_id: "{{ lookup('env', 'AZURE_CLIENT_ID') }}"
    client_secret: "{{ lookup('env', 'AZURE_SECRET') }}"
    

Enregistrez le playbook suivant en tant que aks-create.yml :

- name: Create resource group
  azure_rm_resourcegroup:
      name: "{{ resource_group }}"
      location: "{{ location }}"

- name: List supported kubernetes version from Azure
  azure_rm_aksversion_facts:
      location: "{{ location }}"
  register: versions

- name: Create AKS cluster with RBAC enabled
  azure_rm_aks:
      resource_group: "{{ resource_group }}"
      name: "{{ name }}"
      dns_prefix: "{{ name }}"
      enable_rbac: yes
      kubernetes_version: "{{ versions.azure_aks_versions[-1] }}"
      agent_pool_profiles:
        - count: 3
          name: nodepool1
          vm_size: Standard_D2_v2
      linux_profile:
          admin_username: azureuser
          ssh_key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"
      service_principal:
          client_id: "{{ lookup('ini', 'client_id section=default file=~/.azure/credentials') }}"
          client_secret: "{{ lookup('ini', 'secret section=default file=~/.azure/credentials') }}"
      aad_profile:
          client_app_id: "{{ client_app_id }}"
          server_app_id: "{{ server_app_id }}"
          server_app_secret: "{{ server_app_secret }}"
          tenant_id: "{{ app_tenant_id }}"
  register: aks

- name: Save cluster user config
  copy:
      content: "{{ aks.kube_config }}"
      dest: "aks-{{ name }}-kubeconfig-user"

- name: Get admin config of AKS
  azure_rm_aks_facts:
      resource_group: "{{ resource_group }}"
      name: "{{ name }}"
      show_kubeconfig: admin
  register: aks

- name: Save the kubeconfig
  copy:
      content: "{{ aks.aks[0].kube_config }}"
      dest: "aks-{{ name }}-kubeconfig"

Obtenir l’ID objet Azure AD

Pour créer une liaison RBAC, vous devez d’abord obtenir l’ID d’objet Azure Active Directory.

  1. Connectez-vous au portail Azure.

  2. Dans le champ de recherche en haut de la page, entrez Azure Active Directory.

  3. Cliquez sur Enter.

  4. Dans le menu Gérer, sélectionnez Utilisateurs.

  5. Dans le champ des noms, recherchez votre compte.

  6. Dans la colonne Nom, sélectionnez le lien vers votre compte.

  7. Dans la section Identité, copiez l’ID d’objet.

    Copiez l’ID d’objet Azure AD.

Créer une liaison RBAC

Dans cette section, vous créez une liaison de rôle ou une liaison de rôle de cluster dans AKS.

Enregistrez le playbook suivant en tant que kube-role.yml :

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cluster-admins
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: <your-aad-account>

Remplacez l’espace réservé <your-aad-account> par votre locataire Azure AD ID d’objet.

Enregistrez le manifeste suivant – qui déploie votre nouveau rôle dans AKS – en tant que aks-kube-deploy.yml :

- name: Apply role to AKS
  k8s:
      src: kube-role.yml
      kubeconfig: "aks-{{ name }}-kubeconfig"

Exécutez l’exemple de playbook

Cette section répertorie l’exemple de playbook complet qui appelle les tâches de création dans cet article.

Enregistrez le playbook suivant en tant que aks-rbac.yml :

---
- hosts: localhost
  vars:
      resource_group: aksansibletest
      name: aksansibletest
      location: eastus
  tasks:
     - name: Ensure resource group exist
       azure_rm_resourcegroup:
           name: "{{ resource_group }}"
           location: "{{ location }}"

     - name: Create AKS
       vars:
           client_app_id: <client id>
           server_app_id: <server id>
           server_app_secret: <server secret>
           app_tenant_id: <tenant id>
       include_tasks: aks-create.yml

     - name: Enable RBAC
       include_tasks: aks-kube-deploy.yml

Dans la section vars, remplacez les espaces réservés suivants par vos informations Azure AD :

  • <client id>
  • <server id>
  • <server secret>
  • <tenant id>

Exécutez le playbook complet en utilisant la commande ansible-playbook :

ansible-playbook aks-rbac.yml

Vérifier les résultats

Dans cette section, vous utilisez kubectl pour répertorier les nœuds de création dans cet article.

Entrez la commande suivante à l’invite du terminal :

kubectl --kubeconfig aks-aksansibletest-kubeconfig-user get nodes

La commande vous orientera vers une page d’authentification. Connectez-vous à votre compte Azure.

Une fois authentifié, kubectl répertorie les nœuds de la même façon pour les résultats suivants :

To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code XXXXXXXX to authenticate.
NAME                       STATUS   ROLES   AGE   VERSION
aks-nodepool1-33413200-0   Ready    agent   49m   v1.12.6
aks-nodepool1-33413200-1   Ready    agent   49m   v1.12.6
aks-nodepool1-33413200-2   Ready    agent   49m   v1.12.6

Nettoyer les ressources

Lorsque vous n’en avez plus besoin, supprimez les ressources créées dans cet article.

Enregistrez le code suivant en tant que cleanup.yml :

---
- hosts: localhost
  vars:
      name: aksansibletest
      resource_group: aksansibletest
  tasks:
      - name: Clean up resource group
        azure_rm_resourcegroup:
            name: "{{ resource_group }}"
            state: absent
            force: yes
      - name: Remove kubeconfig
        file:
            state: absent
            path: "aks-{{ name }}-kubeconfig"

Exécutez le playbook en utilisant ansible-playbook

ansible-playbook cleanup.yml

Étapes suivantes