Tutorial: Konfigurieren von Rollen der rollenbasierten Zugriffssteuerung (Role-Based Access Control, RBAC) in Azure Kubernetes Service (AKS) mithilfe von Ansible

Artikel
08/19/2024

Wichtig

Für die Ausführung der Beispielplaybooks in diesem Artikel ist mindestens Ansible 2.8 erforderlich.

Mit Azure Kubernetes Service (AKS) können Sie ganz einfach einen Managed Kubernetes-Cluster in Azure bereitstellen. AKS verringert die Komplexität und den operativen Mehraufwand für die Kubernetes-Verwaltung, indem ein Großteil dieser Verantwortung an Azure übertragen wird. Azure führt als gehosteter Kubernetes-Dienst wichtige Aufgaben für Sie aus, z.B. Systemüberwachung und Wartung. Die Kubernetes-Master werden von Azure verwaltet. Sie verwalten und warten nur die Agent-Knoten. Als Managed Kubernetes-Dienst ist AKS kostenlos. Sie zahlen nur für die Agent-Knoten in den Clustern, nicht für den Master.

AKS kann so konfiguriert werden, dass Microsoft Entra ID für die Benutzerauthentifizierung verwendet wird. Nach der Konfiguration verwenden Sie Ihr Microsoft Entra-Authentifizierungstoken, um sich beim AKS-Cluster anzumelden. Die rollenbasierte Zugriffssteuerung (RBAC) kann auf der Identität eines Benutzers oder auf der Mitgliedschaft in einer Verzeichnisgruppe basieren.

In diesem Artikel werden folgende Vorgehensweisen behandelt:

Erstellen eines Microsoft Entra ID-fähigen AKS-Clusters
Konfigurieren einer RBAC-Rolle im Cluster

Voraussetzungen

Azure-Abonnement: Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Azure-Dienstprinzipal: Erstellen Sie einen Dienstprinzipal, und notieren Sie sich die folgenden Werte: appId, displayName, password und tenant.

Installieren von Ansible: Verwenden Sie eine der folgenden Optionen:
- Installieren und Konfigurieren von Ansible auf einem virtuellen Linux-Computer
- Konfigurieren Sie Azure Cloud Shell. Sollten Sie keinen Zugriff auf einen virtuellen Linux-Computer haben, können Sie mit Ansible einen virtuellen Computer erstellen.

Installieren Sie die RedHat OpenShift-Bibliothek - pip install openshift.

Konfiguration von Microsoft Entra ID für die AKS-Authentifizierung

Beim Konfigurieren von Microsoft Entra ID für die AKS-Authentifizierung werden zwei Microsoft Entra-Anwendungen konfiguriert. Dieser Vorgang muss von einem Azure-Mandantenadministrator ausgeführt werden. Weitere Informationen finden Sie unter Integrieren von Microsoft Entra ID in AKS.

Beschaffen Sie über den Azure-Mandantenadministrator die folgenden Werte:

Server-App-Geheimnis
Server-App-ID
Client-App-ID
Mandanten-ID

Diese Werte werden zum Ausführen des Beispielplaybooks benötigt.

Erstellen eines AKS-Clusters

In diesem Abschnitt erstellen Sie mit der Microsoft Entra-Anwendung eine AKS-Instanz.

Hier sind einige wichtige Hinweise aufgeführt, die Sie beim Arbeiten mit dem Beispielplaybook berücksichtigen sollten:

Das Playbook lädt ssh_key aus ~/.ssh/id_rsa.pub. Verwenden Sie bei etwaigen Änderungen das einzeilige Format, und beginnen Sie die Zeile mit „ssh-rsa“ (ohne Anführungszeichen).
Die Werte client_id und client_secret werden aus ~/.azure/credentials geladen. Dies ist die Standarddatei mit den Anmeldeinformationen. Sie können diese Werte auf Ihren Dienstprinzipal festlegen oder sie aus Umgebungsvariablen laden:
```
client_id: "{{ lookup('env', 'AZURE_CLIENT_ID') }}"
client_secret: "{{ lookup('env', 'AZURE_SECRET') }}"
```

Speichern Sie das folgende Playbook als 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"

Abrufen der Microsoft Entra-Objekt-ID

Zum Erstellen einer RBAC-Bindung müssen Sie zuerst die Microsoft Entra-Objekt-ID abrufen.

Melden Sie sich beim Azure-Portal an.
Geben Sie im Suchfeld oben auf der Seite Microsoft Entra ID ein.
Klicken Sie auf die Enter.
Wählen Sie im Menü Verwalten die Option Benutzer.
Suchen Sie im Namensfeld nach Ihrem Konto.
Wählen Sie in der Spalte Name den Link zu Ihrem Konto aus.
Kopieren Sie im Abschnitt Identität die Objekt-ID.

Erstellen einer RBAC-Bindung

In diesem Abschnitt erstellen Sie eine Rollen- bzw. Clusterrollenbindung in AKS.

Speichern Sie das folgende Playbook als 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>

Ersetzen Sie den Platzhalter <your-aad-account> durch die Objekt-ID Ihres Microsoft Entra-Mandanten.

Speichern Sie das folgende Playbook, mit dem Ihre neue Rolle in AKS bereitgestellt wird, als aks-kube-deploy.yml:

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

Ausführen des Beispielplaybooks

Dieser Abschnitt enthält das vollständige Beispielplaybook, mit dem die in diesem Artikel erstellten Aufgaben aufgerufen werden.

Speichern Sie das folgende Playbook als 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

Ersetzen Sie im Abschnitt vars die folgenden Platzhalter durch Ihre Microsoft Entra-Informationen:

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

Führen Sie das vollständige Playbook mit dem Befehl ansible-playbook aus:

ansible-playbook aks-rbac.yml

Überprüfen der Ergebnisse

In diesem Abschnitt nutzen Sie kubectl, um die in diesem Artikel erstellten Knoten aufzulisten.

Geben Sie den folgenden Befehl an einer Terminaleingabeaufforderung ein:

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

Mit dem Befehl gelangen Sie zu einer Authentifizierungsseite. Melden Sie sich mit Ihrem Azure-Konto an.

Nach der Authentifizierung werden die Knoten von kubectl in etwa wie folgt aufgelistet:

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

Bereinigen von Ressourcen

Löschen Sie die in diesem Artikel erstellten Ressourcen, wenn Sie sie nicht mehr benötigen.

Speichern Sie den folgenden Code als 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"

Führen Sie das Playbook mithilfe von ansible-playbook aus.

ansible-playbook cleanup.yml

Nächste Schritte

Ansible unter Azure

Freigeben über